image-color-analyst 1.0.4

package/README.md

@@ -0,0 +1,23 @@
+# Image Color Analyzer 🎨
+
+A Node.js package to analyze images and extract dominant colors, color palettes, and color statistics.
+
+## Features
+
+- 🎯 Extract dominant color from images
+- 🏆 Get top N colors with percentages
+- 📊 Color statistics and analysis
+- 🎨 Generate color palettes
+- 💅 CSS variable generation
+- 🖥️ CLI interface
+- 🌐 Express.js API server
+- 🚀 Fast processing with Sharp
+
+## Installation
+
+```bash
+# Install globally for CLI usage
+npm install -g image-color-analyzer
+
+# Install as dependency for your project
+npm install image-color-analyzer

package/bin/cli.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+// Use ES module imports
+import { program } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+
+// For local modules, still use require
+const { analyze, getDominantColor, getColorPalette } = require('../src/index');
+
+// Display banner
+console.log(
+  chalk.cyan(
+    '='.repeat(60) + '\n' +
+    '🎨  IMAGE COLOR ANALYZER  🎨\n' +
+    '='.repeat(60)
+  )
+);
+
+program
+  .name('color-analyzer')
+  .description('CLI tool to analyze dominant colors in images')
+  .version('1.0.0');
+
+program
+  .command('analyze <image-path>')
+  .description('Analyze an image and get color information')
+  .option('-t, --top <number>', 'Number of top colors to show', '5')
+  .option('-o, --output <format>', 'Output format (json, table, simple)', 'table')
+  .option('-s, --save <filename>', 'Save results to JSON file')
+  .action(async (imagePath, options) => {
+    try {
+      // Check if file exists
+      if (!fs.existsSync(imagePath)) {
+        console.error(chalk.red(`Error: File not found - ${imagePath}`));
+        process.exit(1);
+      }
+
+      console.log(chalk.blue(`📷 Analyzing ${imagePath}...\n`));
+      
+      const result = await analyze(imagePath, {
+        topColorsCount: parseInt(options.top)
+      });
+
+      if (options.output === 'json') {
+        console.log(JSON.stringify(result, null, 2));
+      } else if (options.output === 'simple') {
+        console.log(chalk.bold('🎨 Dominant Color:'));
+        console.log(`  ${result.dominantColor.hex} - ${result.dominantColor.name}`);
+        console.log(`  Percentage: ${result.dominantColor.percentage}%\n`);
+        
+        console.log(chalk.bold('🏆 Top Colors:'));
+        result.topColors.forEach((color, index) => {
+          console.log(`  ${index + 1}. ${color.hex} - ${color.name} (${color.percentage}%)`);
+        });
+      } else {
+        // Table format (default)
+        console.log(chalk.bold('📊 Image Information:'));
+        console.log(`  Dimensions: ${result.imageInfo.width} × ${result.imageInfo.height}`);
+        console.log(`  Format: ${result.imageInfo.format}`);
+        console.log(`  Processing Time: ${result.processingTime}ms\n`);
+        
+        console.log(chalk.bold('🎨 Dominant Color:'));
+        console.log(chalk.bgHex(result.dominantColor.hex)('     '), 
+                   ` ${result.dominantColor.hex} - ${result.dominantColor.name}`);
+        console.log(`  RGB: ${result.dominantColor.rgb}`);
+        console.log(`  Percentage: ${result.dominantColor.percentage}%\n`);
+        
+        console.log(chalk.bold('🏆 Top Colors:'));
+        console.log(chalk.cyan('  Rank  Color        Name        Percentage'));
+        console.log(chalk.cyan('  ────────────────────────────────────────'));
+        
+        result.topColors.forEach((color, index) => {
+          const rank = (index + 1).toString().padEnd(5);
+          const colorBlock = chalk.bgHex(color.hex)('   ');
+          const hex = color.hex.padEnd(10);
+          const name = color.name.padEnd(12);
+          const percentage = color.percentage.toFixed(2).padEnd(8);
+          
+          console.log(`  ${rank} ${colorBlock} ${hex} ${name} ${percentage}%`);
+        });
+        
+        console.log(`\n📈 Total unique colors: ${result.colorStats.totalColors}`);
+      }
+
+      // Save to file if requested
+      if (options.save) {
+        fs.writeFileSync(options.save, JSON.stringify(result, null, 2));
+        console.log(chalk.green(`\n✅ Results saved to ${options.save}`));
+      }
+
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+program
+  .command('dominant <image-path>')
+  .description('Get only the dominant color of an image')
+  .action(async (imagePath) => {
+    try {
+      const dominant = await getDominantColor(imagePath);
+      console.log(chalk.bgHex(dominant.hex)('     '), 
+                 chalk.bold(` ${dominant.hex} - ${dominant.name}`));
+      console.log(`RGB: ${dominant.rgb}`);
+      console.log(`Percentage: ${dominant.percentage}%`);
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+    }
+  });
+
+program
+  .command('palette <image-path>')
+  .description('Extract color palette from image')
+  .option('-c, --colors <number>', 'Number of colors in palette', '5')
+  .action(async (imagePath, options) => {
+    try {
+      const palette = await getColorPalette(imagePath, parseInt(options.colors));
+      
+      console.log(chalk.bold(`🎨 Color Palette (${options.colors} colors):\n`));
+      
+      palette.forEach((color, index) => {
+        const swatch = chalk.bgHex(color.hex)('     ');
+        console.log(`${swatch} ${color.hex.padEnd(10)} ${color.name.padEnd(12)} ${color.percentage.toFixed(2)}%`);
+      });
+      
+      // Generate CSS
+      console.log(chalk.bold('\n💅 CSS Variables:'));
+      palette.forEach((color, index) => {
+        console.log(`--color-${index + 1}: ${color.hex};`);
+      });
+      
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+    }
+  });
+
+program.parse();

package/examples/server.js

@@ -0,0 +1,91 @@
+const express = require('express');
+const multer = require('multer');
+const { analyze } = require('../src/index');
+const path = require('path');
+const fs = require('fs');
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+// Create uploads directory
+const uploadDir = 'uploads';
+if (!fs.existsSync(uploadDir)) {
+  fs.mkdirSync(uploadDir);
+}
+
+// Configure multer
+const storage = multer.diskStorage({
+  destination: (req, file, cb) => {
+    cb(null, uploadDir);
+  },
+  filename: (req, file, cb) => {
+    cb(null, Date.now() + path.extname(file.originalname));
+  }
+});
+
+const upload = multer({
+  storage,
+  limits: { fileSize: 10 * 1024 * 1024 },
+  fileFilter: (req, file, cb) => {
+    if (!file.originalname.match(/\.(jpg|jpeg|png|gif|webp|bmp)$/)) {
+      return cb(new Error('Only image files are allowed!'), false);
+    }
+    cb(null, true);
+  }
+});
+
+// Middleware
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+// Routes
+app.get('/', (req, res) => {
+  res.json({
+    message: 'Image Color Analyzer API',
+    endpoints: {
+      analyze: 'POST /analyze',
+      health: 'GET /health'
+    }
+  });
+});
+
+app.get('/health', (req, res) => {
+  res.json({ status: 'OK', timestamp: new Date().toISOString() });
+});
+
+app.post('/analyze', upload.single('image'), async (req, res) => {
+  try {
+    if (!req.file) {
+      return res.status(400).json({
+        success: false,
+        error: 'No image file provided'
+      });
+    }
+
+    const result = await analyze(req.file.path, {
+      topColorsCount: 10,
+      includeNames: true
+    });
+
+    // Add file info
+    result.fileInfo = {
+      filename: req.file.filename,
+      originalname: req.file.originalname,
+      size: req.file.size,
+      mimetype: req.file.mimetype
+    };
+
+    res.json(result);
+
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+app.listen(PORT, () => {
+  console.log(`🚀 Server running on http://localhost:${PORT}`);
+  console.log(`📁 Upload endpoint: POST http://localhost:${PORT}/analyze`);
+});

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "image-color-analyst",
+  "version": "1.0.4",
+  "description": "Analyze images to find dominant colors and color distribution",
+  "main": "src/index.js",
+  "type": "commonjs",
+  "bin": {
+    "color-analyzer": "./bin/cli.js"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "dev": "node examples/server.js",
+    "test": "jest --passWithNoTests",
+    "lint": "eslint src/",
+    "format": "prettier --write \"src/**/*.js\"",
+    "prepublishOnly": "npm test"
+  },
+  "keywords": [
+    "image",
+    "color",
+    "analyzer",
+    "dominant-color",
+    "palette",
+    "color-analysis",
+    "image-processing"
+  ],
+  "author": "Krishna Pada Mandal",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/KrishnaPadaMandal/image-color-analyzer.git"
+  },
+  "homepage": "https://github.com/KrishnaPadaMandal/image-color-analyzer#readme",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "figlet": "^1.7.0",
+    "sharp": "^0.33.2"
+  },
+  "devDependencies": {
+    "eslint": "^8.52.0",
+    "jest": "^29.7.0",
+    "nodemon": "^3.0.1",
+    "prettier": "^3.0.3"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "src/",
+    "bin/",
+    "examples/",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/analyzer.js

@@ -0,0 +1,175 @@
+const sharp = require('sharp');
+const { rgbToHex, getColorName } = require('./color-utils');
+
+/**
+ * Analyze an image to find dominant colors
+ * @param {string} imagePath - Path to the image file
+ * @param {Object} options - Analysis options
+ * @returns {Promise<Object>} Analysis results
+ */
+async function analyzeImageColors(imagePath, options = {}) {
+  const {
+    maxDimension = 200,
+    topColorsCount = 10,
+    colorQuantization = 10,
+    includeNames = true,
+    includeStats = true
+  } = options;
+  
+  const startTime = Date.now();
+  
+  try {
+    // Read image metadata
+    const metadata = await sharp(imagePath).metadata();
+    
+    // Resize image for processing
+    let width = metadata.width;
+    let height = metadata.height;
+    
+    if (width > maxDimension || height > maxDimension) {
+      if (width > height) {
+        height = Math.round((height * maxDimension) / width);
+        width = maxDimension;
+      } else {
+        width = Math.round((width * maxDimension) / height);
+        height = maxDimension;
+      }
+    }
+    
+    // Get pixel data
+    const { data, info } = await sharp(imagePath)
+      .resize(width, height)
+      .raw()
+      .toBuffer({ resolveWithObject: true });
+    
+    const pixelData = new Uint8Array(data);
+    const colorMap = new Map();
+    const totalPixels = info.width * info.height;
+    
+    // Process each pixel
+    for (let i = 0; i < pixelData.length; i += info.channels) {
+      const r = pixelData[i];
+      const g = pixelData[i + 1];
+      const b = pixelData[i + 2];
+      
+      // Quantize colors
+      const quantizedR = Math.floor(r / colorQuantization) * colorQuantization;
+      const quantizedG = Math.floor(g / colorQuantization) * colorQuantization;
+      const quantizedB = Math.floor(b / colorQuantization) * colorQuantization;
+      
+      const colorKey = `${quantizedR},${quantizedG},${quantizedB}`;
+      
+      if (colorMap.has(colorKey)) {
+        colorMap.set(colorKey, colorMap.get(colorKey) + 1);
+      } else {
+        colorMap.set(colorKey, 1);
+      }
+    }
+    
+    // Convert to array and sort
+    const colorArray = Array.from(colorMap, ([colorKey, count]) => {
+      const [r, g, b] = colorKey.split(',').map(Number);
+      const hex = rgbToHex(r, g, b);
+      const percentage = (count / totalPixels) * 100;
+      
+      const colorObj = {
+        rgb: `rgb(${r}, ${g}, ${b})`,
+        hex,
+        r, g, b,
+        count,
+        percentage: parseFloat(percentage.toFixed(2))
+      };
+      
+      // Add color name if requested
+      if (includeNames) {
+        colorObj.name = getColorName(r, g, b);
+      }
+      
+      return colorObj;
+    });
+    
+    // Sort by frequency
+    colorArray.sort((a, b) => b.count - a.count);
+    
+    // Get top colors
+    const topColors = colorArray.slice(0, topColorsCount);
+    const dominantColor = topColors[0] || null;
+    
+    // Prepare results
+    const result = {
+      success: true,
+      dominantColor,
+      topColors,
+      imageInfo: {
+        width: metadata.width,
+        height: metadata.height,
+        format: metadata.format,
+        channels: metadata.channels,
+        size: metadata.size || 0
+      },
+      processingTime: Date.now() - startTime
+    };
+    
+    // Add stats if requested
+    if (includeStats) {
+      result.colorStats = {
+        totalColors: colorArray.length,
+        totalPixels: totalPixels,
+        processedPixels: totalPixels
+      };
+    }
+    
+    return result;
+    
+  } catch (error) {
+    throw new Error(`Image analysis failed: ${error.message}`);
+  }
+}
+
+/**
+ * Get color statistics from analysis results
+ * @param {Array} colors - Array of color objects
+ * @returns {Object} Color statistics
+ */
+function getColorStats(colors) {
+  if (!colors || !Array.isArray(colors) || colors.length === 0) {
+    return null;
+  }
+  
+  const stats = {
+    totalColors: colors.length,
+    colorDistribution: {},
+    averageSaturation: 0,
+    averageLightness: 0
+  };
+  
+  let totalSaturation = 0;
+  let totalLightness = 0;
+  
+  colors.forEach(color => {
+    // Calculate HSL values
+    const max = Math.max(color.r, color.g, color.b);
+    const min = Math.min(color.r, color.g, color.b);
+    const lightness = ((max + min) / 2 / 255) * 100;
+    const delta = (max - min) / 255;
+    const saturation = lightness === 0 || lightness === 1 ? 0 : 
+                      delta / (1 - Math.abs(2 * lightness - 1)) * 100;
+    
+    totalSaturation += saturation;
+    totalLightness += lightness;
+    
+    // Track color distribution by name
+    const name = color.name || getColorName(color.r, color.g, color.b);
+    stats.colorDistribution[name] = (stats.colorDistribution[name] || 0) + color.percentage;
+  });
+  
+  stats.averageSaturation = parseFloat((totalSaturation / colors.length).toFixed(2));
+  stats.averageLightness = parseFloat((totalLightness / colors.length).toFixed(2));
+  
+  return stats;
+}
+
+module.exports = {
+  analyzeImageColors,
+  getColorStats
+};

package/src/color-utils.js

@@ -0,0 +1,121 @@
+/**
+ * Convert RGB to HEX
+ * @param {number} r - Red (0-255)
+ * @param {number} g - Green (0-255)
+ * @param {number} b - Blue (0-255)
+ * @returns {string} HEX color code
+ */
+function rgbToHex(r, g, b) {
+  return "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1).toUpperCase();
+}
+
+/**
+ * Convert HEX to RGB
+ * @param {string} hex - HEX color code
+ * @returns {Object} RGB object
+ */
+function hexToRgb(hex) {
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result ? {
+    r: parseInt(result[1], 16),
+    g: parseInt(result[2], 16),
+    b: parseInt(result[3], 16)
+  } : null;
+}
+
+/**
+ * Get color name from RGB values
+ * @param {number} r - Red (0-255)
+ * @param {number} g - Green (0-255)
+ * @param {number} b - Blue (0-255)
+ * @returns {string} Color name
+ */
+function getColorName(r, g, b) {
+  const hue = getHue(r, g, b);
+  const saturation = getSaturation(r, g, b);
+  const lightness = getLightness(r, g, b);
+  
+  if (lightness < 20) return "Black";
+  if (lightness > 85) return "White";
+  if (saturation < 15) return "Gray";
+  
+  if (hue >= 0 && hue < 15) return "Red";
+  if (hue >= 15 && hue < 45) return "Orange";
+  if (hue >= 45 && hue < 75) return "Yellow";
+  if (hue >= 75 && hue < 165) return "Green";
+  if (hue >= 165 && hue < 195) return "Cyan";
+  if (hue >= 195 && hue < 255) return "Blue";
+  if (hue >= 255 && hue < 285) return "Purple";
+  if (hue >= 285 && hue < 330) return "Pink";
+  return "Red";
+}
+
+/**
+ * Calculate hue from RGB
+ * @param {number} r - Red
+ * @param {number} g - Green
+ * @param {number} b - Blue
+ * @returns {number} Hue value (0-360)
+ */
+function getHue(r, g, b) {
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  let hue = 0;
+  
+  if (max === min) {
+    hue = 0;
+  } else {
+    const delta = max - min;
+    if (max === r) {
+      hue = ((g - b) / delta) % 6;
+    } else if (max === g) {
+      hue = (b - r) / delta + 2;
+    } else {
+      hue = (r - g) / delta + 4;
+    }
+    
+    hue = Math.round(hue * 60);
+    if (hue < 0) hue += 360;
+  }
+  
+  return hue;
+}
+
+/**
+ * Calculate saturation from RGB
+ * @param {number} r - Red
+ * @param {number} g - Green
+ * @param {number} b - Blue
+ * @returns {number} Saturation percentage
+ */
+function getSaturation(r, g, b) {
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const lightness = (max + min) / 2 / 255;
+  const delta = (max - min) / 255;
+  
+  if (lightness === 0 || lightness === 1) return 0;
+  return parseFloat((delta / (1 - Math.abs(2 * lightness - 1)) * 100).toFixed(2));
+}
+
+/**
+ * Calculate lightness from RGB
+ * @param {number} r - Red
+ * @param {number} g - Green
+ * @param {number} b - Blue
+ * @returns {number} Lightness percentage
+ */
+function getLightness(r, g, b) {
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  return parseFloat((((max + min) / 2 / 255) * 100).toFixed(2));
+}
+
+module.exports = {
+  rgbToHex,
+  hexToRgb,
+  getColorName,
+  getHue,
+  getSaturation,
+  getLightness
+};

package/src/index.js

@@ -0,0 +1,50 @@
+const { analyzeImageColors, getColorStats } = require('./analyzer');
+const { rgbToHex, getColorName, hexToRgb } = require('./color-utils');
+
+module.exports = {
+  // Core functions
+  analyzeImageColors,
+  getColorStats,
+  
+  // Color utilities
+  rgbToHex,
+  getColorName,
+  hexToRgb,
+  
+  // Main analyzer function with options
+  analyze: async (imagePath, options = {}) => {
+    const defaultOptions = {
+      maxDimension: 200,
+      topColorsCount: 10,
+      colorQuantization: 10,
+      includeNames: true,
+      includeStats: true
+    };
+    
+    const mergedOptions = { ...defaultOptions, ...options };
+    
+    try {
+      const result = await analyzeImageColors(imagePath, mergedOptions);
+      return result;
+    } catch (error) {
+      throw new Error(`Color analysis failed: ${error.message}`);
+    }
+  },
+  
+  // Quick analyze for dominant color only
+  getDominantColor: async (imagePath, options = {}) => {
+    const result = await analyzeImageColors(imagePath, {
+      ...options,
+      topColorsCount: 1
+    });
+    return result.dominantColor;
+  },
+  
+  // Get color palette
+  getColorPalette: async (imagePath, count = 5) => {
+    const result = await analyzeImageColors(imagePath, {
+      topColorsCount: count
+    });
+    return result.topColors;
+  }
+};