Query Imagery

# 100 most recent infrared images
curl "https://avert.ldeo.columbia.edu/api/imagery/q"

# 50 visible images
curl "https://avert.ldeo.columbia.edu/api/imagery/q?imageType=visible&limit=50"

# 5 images for quick testing
curl "https://avert.ldeo.columbia.edu/api/imagery/q?limit=5"

# Images from Cleveland site
curl "https://avert.ldeo.columbia.edu/api/imagery/q?site=CLNE&limit=50"

# Images from Poás volcano
curl "https://avert.ldeo.columbia.edu/api/imagery/q?vnum=345040&limit=100"

# November 2025
curl "https://avert.ldeo.columbia.edu/api/imagery/q?\
datefrom=20251101000000&\
dateto=20251130235959&\
limit=100"

# March 21, 2025
curl "https://avert.ldeo.columbia.edu/api/imagery/q?\
datefrom=20250321000000&\
dateto=20250321235959&\
limit=50"

# After November 1, 2025
curl "https://avert.ldeo.columbia.edu/api/imagery/q?\
datefrom=20251101000000&\
limit=100"

# Clear daytime visible images
curl "https://avert.ldeo.columbia.edu/api/imagery/q?\
imageType=visible&\
is_night=false&\
low_visibility=false&\
is_empty=false&\
limit=50"

# Clear, non-degraded infrared images
curl "https://avert.ldeo.columbia.edu/api/imagery/q?\
imageType=infrared&\
is_degraded=false&\
low_visibility=false&\
is_empty=false&\
limit=50"

# One image per hour from November
curl "https://avert.ldeo.columbia.edu/api/imagery/q?\
site=VPMI&\
freq=hourly&\
datefrom=20251101000000&\
dateto=20251130235959&\
limit=200"

# Daily snapshots for entire year
curl "https://avert.ldeo.columbia.edu/api/imagery/q?\
site=CLNE&\
freq=daily&\
datefrom=20250101000000&\
dateto=20251231235959"

# Step 1: Get download estimate
curl "https://avert.ldeo.columbia.edu/api/imagery/q?\
site=VPMI&\
datefrom=20251201000000&\
dateto=20251201235959&\
download=estimate"

# Response shows: 1440 images, 239 MB, 24 seconds

# Step 2: Download the images
curl "https://avert.ldeo.columbia.edu/api/imagery/q?\
site=VPMI&\
datefrom=20251201000000&\
dateto=20251201235959&\
download=true" \
-o images.zip

# Download 10 images for testing
curl "https://avert.ldeo.columbia.edu/api/imagery/q?\
limit=10&\
download=true" \
-o test.zip

// Query recent infrared images
const response = await fetch(
  'https://avert.ldeo.columbia.edu/api/imagery/q?imageType=infrared&limit=20'
);
const data = await response.json();

console.log(`Total results: ${data.results.length}`);
console.log(`Page ${data.pagination.page} of ${data.pagination.total_pages}`);

// Display images
data.results.forEach(img => {
  const imgElement = document.createElement('img');
  imgElement.src = img.image_url;
  imgElement.alt = img.image_id;
  document.body.appendChild(imgElement);
});

// Query with multiple filters
const params = new URLSearchParams({
  imageType: 'infrared',
  site: 'CLNE',
  is_degraded: 'false',
  low_visibility: 'false',
  is_empty: 'false',
  datefrom: '20251101000000',
  dateto: '20251130235959',
  limit: '50'
});

const response = await fetch(
  `https://avert.ldeo.columbia.edu/api/imagery/q?${params}`
);
const data = await response.json();

// Load specific page
async function loadPage(pageNum) {
  const response = await fetch(
    `https://avert.ldeo.columbia.edu/api/imagery/q?limit=50&page=${pageNum}`
  );
  const data = await response.json();
  
  console.log(`Page ${data.pagination.page} of ${data.pagination.total_pages}`);
  console.log(`Has next: ${data.pagination.has_next}`);
  
  return data;
}

// Load next page
if (data.pagination.has_next) {
  const nextPage = await loadPage(data.pagination.next_page);
}

// Frontend: Download with user confirmation
async function downloadImagesWithEstimate(filters) {
  // Step 1: Get estimate
  const estimateUrl = `https://avert.ldeo.columbia.edu/api/imagery/q?${filters}&download=estimate`;
  const estimate = await fetch(estimateUrl).then(r => r.json());
  
  const {total_images, estimated_size_mb, estimated_time_seconds, warning, suggestion} = estimate;
  
  // Step 2: Show confirmation
  let message = `Download ${total_images} images (${estimated_size_mb} MB)?\nEstimated time: ${estimated_time_seconds} seconds`;
  
  if (warning === 'large_dataset') {
    message += `\n\n⚠️ Large download!\n${suggestion}`;
  }
  
  if (confirm(message)) {
    // Step 3: Trigger download
    showLoadingSpinner(`Preparing ${total_images} images...`);
    window.location.href = `https://avert.ldeo.columbia.edu/api/imagery/q?${filters}&download=true`;
  }
}

// Usage
const filters = 'site=VPMI&datefrom=20251101000000&dateto=20251130235959&freq=hourly';
downloadImagesWithEstimate(filters);

import requests

# Query recent infrared images
response = requests.get(
    'https://avert.ldeo.columbia.edu/api/imagery/q',
    params={
        'imageType': 'infrared',
        'site': 'CLNE',
        'limit': 50
    }
)
data = response.json()

print(f"Total results: {len(data['results'])}")
print(f"Page {data['pagination']['page']} of {data['pagination']['total_pages']}")

for img in data['results']:
    print(f"{img['image_id']}: {img['image_url']}")

# Query with date range and conditions
response = requests.get(
    'https://avert.ldeo.columbia.edu/api/imagery/q',
    params={
        'imageType': 'infrared',
        'site': 'CLNE',
        'datefrom': '20251101000000',
        'dateto': '20251130235959',
        'is_degraded': False,
        'low_visibility': False,
        'is_empty': False,
        'limit': 100
    }
)
data = response.json()

def get_all_pages(base_params, max_pages=None):
    """Fetch all pages of results"""
    all_results = []
    page = 1
    
    while True:
        params = {**base_params, 'page': page}
        response = requests.get(
            'https://avert.ldeo.columbia.edu/api/imagery/q',
            params=params
        )
        data = response.json()
        
        all_results.extend(data['results'])
        
        if not data['pagination']['has_next']:
            break
        
        if max_pages and page >= max_pages:
            break
            
        page += 1
    
    return all_results

# Usage
all_images = get_all_pages({
    'site': 'CLNE',
    'limit': 100
}, max_pages=5)

print(f"Fetched {len(all_images)} total images")

def download_with_estimate(filters):
    """Download images with estimate confirmation"""
    # Step 1: Get estimate
    estimate_response = requests.get(
        'https://avert.ldeo.columbia.edu/api/imagery/q',
        params={**filters, 'download': 'estimate'}
    )
    estimate = estimate_response.json()
    
    total = estimate['total_images']
    size_mb = estimate['estimated_size_mb']
    time_sec = estimate['estimated_time_seconds']
    warning = estimate.get('warning')
    suggestion = estimate.get('suggestion')
    
    # Step 2: Confirm with user
    print(f"Download {total} images ({size_mb} MB)?")
    print(f"Estimated time: {time_sec} seconds")
    
    if warning:
        print(f"⚠️ Warning: {suggestion}")
    
    confirm = input("Continue? (y/n): ")
    
    if confirm.lower() == 'y':
        # Step 3: Download
        print(f"Downloading {total} images...")
        download_response = requests.get(
            'https://avert.ldeo.columbia.edu/api/imagery/q',
            params={**filters, 'download': 'true'}
        )
        
        with open('images.zip', 'wb') as f:
            f.write(download_response.content)
        
        print(f"✓ Downloaded {total} images to images.zip")

# Usage
filters = {
    'site': 'VPMI',
    'freq': 'hourly',
    'datefrom': '20251101000000',
    'dateto': '20251130235959'
}
download_with_estimate(filters)

# Get hourly snapshots for time-lapse
response = requests.get(
    'https://avert.ldeo.columbia.edu/api/imagery/q',
    params={
        'site': 'VPMI',
        'freq': 'hourly',
        'datefrom': '20251101000000',
        'dateto': '20251130235959',
        'limit': 100
    }
)
hourly_images = response.json()

print(f"Hourly images: {len(hourly_images['results'])}")

import requests
import time

def query_with_retry(url, params, max_retries=3):
    """Query with exponential backoff on rate limits"""
    for attempt in range(max_retries):
        response = requests.get(url, params=params)
        
        if response.status_code == 200:
            return response.json()
        elif response.status_code == 429:
            # Rate limited - wait and retry
            wait_time = 2 ** attempt  # Exponential backoff
            print(f"Rate limited. Waiting {wait_time} seconds...")
            time.sleep(wait_time)
        else:
            response.raise_for_status()
    
    raise Exception("Max retries exceeded")

# Usage
data = query_with_retry(
    'https://avert.ldeo.columbia.edu/api/imagery/q',
    params={'limit': 50, 'site': 'CLNE'}
)

async function queryWithRetry(url, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const response = await fetch(url);
    
    if (response.ok) {
      return await response.json();
    } else if (response.status === 429) {
      // Rate limited - wait and retry
      const waitTime = Math.pow(2, attempt) * 1000; // Exponential backoff
      console.log(`Rate limited. Waiting ${waitTime/1000} seconds...`);
      await new Promise(resolve => setTimeout(resolve, waitTime));
    } else {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
  }
  
  throw new Error('Max retries exceeded');
}

// Usage
const data = await queryWithRetry(
  'https://avert.ldeo.columbia.edu/api/imagery/q?limit=50&site=CLNE'
);