उपयोगिता API

Sharp छवि प्रसंस्करण और प्रारूप रूपांतरण में सहायता के लिए कई उपयोगिता फ़ंक्शन प्रदान करता है।

प्रारूप पहचान

समर्थित प्रारूपों का पता लगाना

import sharp from 'sharp';

// समर्थित इनपुट प्रारूप प्राप्त करें
console.log('समर्थित इनपुट प्रारूप:', sharp.format);

// समर्थित आउटपुट प्रारूप प्राप्त करें
console.log('समर्थित आउटपुट प्रारूप:', sharp.format);

फ़ाइल प्रारूप जांचना

async function checkImageFormat(filePath) {
  try {
    const metadata = await sharp(filePath).metadata();
    return {
      format: metadata.format,
      width: metadata.width,
      height: metadata.height,
      channels: metadata.channels
    };
  } catch (error) {
    return { error: error.message };
  }
}

रंग स्थान

रंग स्थान स्थिरांक

// उपलब्ध रंग स्थान
sharp.colourspace.srgb      // sRGB
sharp.colourspace.rgb       // RGB
sharp.colourspace.cmyk      // CMYK
sharp.colourspace.grey      // ग्रेस्केल
sharp.colourspace.multiband // मल्टीबैंड
sharp.colourspace.lab       // Lab
sharp.colourspace.xyz       // XYZ
sharp.colourspace.ycbcr     // YCbCr

रंग स्थान रूपांतरण

// ग्रेस्केल में रूपांतरित करें
sharp('input.jpg')
  .grayscale()
  .toFile('output.jpg');

// CMYK में रूपांतरित करें
sharp('input.jpg')
  .toColourspace(sharp.colourspace.cmyk)
  .tiff()
  .toFile('output.tiff');

कर्नेल और फ़िल्टर

आकार समायोजन कर्नेल

// उपलब्ध आकार समायोजन कर्नेल
sharp.kernel.nearest      // निकटतम पड़ोसी
sharp.kernel.cubic        // क्यूबिक इंटरपोलेशन
sharp.kernel.mitchell     // Mitchell-Netravali
sharp.kernel.lanczos2     // Lanczos 2-lobed
sharp.kernel.lanczos3     // Lanczos 3-lobed (डिफ़ॉल्ट)

कस्टम कर्नेल का उपयोग

// कस्टम आकार समायोजन कर्नेल का उपयोग करें
sharp('input.jpg')
  .resize(300, 200, { kernel: sharp.kernel.lanczos3 })
  .toFile('output.jpg');

स्थिति स्थिरांक

स्थिति विकल्प

// उपलब्ध स्थिति विकल्प
sharp.position.top         // शीर्ष
sharp.position.right       // दाईं ओर
sharp.position.bottom      // नीचे
sharp.position.left        // बाईं ओर
sharp.position.center      // केंद्र (डिफ़ॉल्ट)
sharp.position.centre      // केंद्र (ब्रिटिश वर्तनी)
sharp.position.north       // उत्तर (शीर्ष)
sharp.position.east        // पूर्व (दाईं ओर)
sharp.position.south       // दक्षिण (नीचे)
sharp.position.west        // पश्चिम (बाईं ओर)
sharp.position.northeast   // उत्तर-पूर्व
sharp.position.southeast   // दक्षिण-पूर्व
sharp.position.southwest   // दक्षिण-पश्चिम
sharp.position.northwest   // उत्तर-पश्चिम

चैनल ऑपरेशन

चैनल स्थिरांक

// चैनल स्थिरांक
sharp.channel.red          // लाल चैनल
sharp.channel.green        // हरा चैनल
sharp.channel.blue         // नीला चैनल
sharp.channel.alpha        // पारदर्शिता चैनल
sharp.channel.grey         // ग्रेस्केल चैनल

चैनल ऑपरेशन

// लाल चैनल निकालें
sharp('input.jpg')
  .extractChannel(sharp.channel.red)
  .toFile('red-channel.jpg');

// सभी चैनल निकालें
const channels = await sharp('input.jpg').separate();

त्रुटि प्रबंधन

त्रुटि प्रकार

// सामान्य Sharp त्रुटियां
sharp.errors.InputError     // इनपुट त्रुटि
sharp.errors.ProcessError   // प्रसंस्करण त्रुटि
sharp.errors.OutputError    // आउटपुट त्रुटि

त्रुटि प्रबंधन उदाहरण

try {
  await sharp('input.jpg')
    .resize(300, 200)
    .toFile('output.jpg');
} catch (error) {
  if (error instanceof sharp.errors.InputError) {
    console.error('इनपुट फ़ाइल त्रुटि:', error.message);
  } else if (error instanceof sharp.errors.ProcessError) {
    console.error('प्रसंस्करण त्रुटि:', error.message);
  } else if (error instanceof sharp.errors.OutputError) {
    console.error('आउटपुट त्रुटि:', error.message);
  } else {
    console.error('अज्ञात त्रुटि:', error.message);
  }
}

प्रदर्शन निगरानी

मेमोरी उपयोग

// Sharp मेमोरी उपयोग प्राप्त करें
const stats = sharp.cache();
console.log('कैश सांख्यिकी:', stats);

// कैश साफ़ करें
sharp.cache(false);

समवर्ती नियंत्रण

// समवर्ती सीमा सेट करें
sharp.concurrency(4); // अधिकतम 4 समवर्ती ऑपरेशन

// वर्तमान समवर्ती संख्या प्राप्त करें
console.log('वर्तमान समवर्ती संख्या:', sharp.concurrency());

उपकरण फ़ंक्शन

परीक्षण छवि बनाना

// ठोस रंग छवि बनाएं
const redImage = sharp({
  create: {
    width: 300,
    height: 200,
    channels: 3,
    background: { r: 255, g: 0, b: 0 }
  }
});

// ग्रेडिएंट छवि बनाएं
const gradient = sharp({
  create: {
    width: 300,
    height: 200,
    channels: 3,
    background: { r: 0, g: 0, b: 0 }
  }
});

छवि संयोजन

// कई छवियों को संयोजित करें
const composite = await sharp('background.jpg')
  .composite([
    {
      input: 'overlay.png',
      top: 100,
      left: 100
    }
  ])
  .jpeg()
  .toBuffer();

बैच प्रसंस्करण उपकरण

बैच आकार बदलना

const fs = require('fs').promises;

async function batchResize(inputDir, outputDir, width, height) {
  const files = await fs.readdir(inputDir);
  
  for (const file of files) {
    if (file.match(/\.(jpg|jpeg|png|webp)$/i)) {
      try {
        await sharp(`${inputDir}/${file}`)
          .resize(width, height)
          .jpeg({ quality: 80 })
          .toFile(`${outputDir}/${file}`);
        
        console.log(`प्रसंस्करण पूर्ण: ${file}`);
      } catch (error) {
        console.error(`${file} प्रसंस्करण विफल:`, error.message);
      }
    }
  }
}

बैच प्रारूप रूपांतरण

async function batchConvert(inputDir, outputDir, format) {
  const files = await fs.readdir(inputDir);
  
  for (const file of files) {
    if (file.match(/\.(jpg|jpeg|png|webp)$/i)) {
      const outputFile = file.replace(/\.[^.]+$/, `.${format}`);
      
      try {
        const image = sharp(`${inputDir}/${file}`);
        
        switch (format) {
          case 'jpg':
          case 'jpeg':
            await image.jpeg({ quality: 80 }).toFile(`${outputDir}/${outputFile}`);
            break;
          case 'png':
            await image.png().toFile(`${outputDir}/${outputFile}`);
            break;
          case 'webp':
            await image.webp({ quality: 80 }).toFile(`${outputDir}/${outputFile}`);
            break;
          case 'avif':
            await image.avif({ quality: 80 }).toFile(`${outputDir}/${outputFile}`);
            break;
        }
        
        console.log(`रूपांतरण पूर्ण: ${file} -> ${outputFile}`);
      } catch (error) {
        console.error(`${file} रूपांतरण विफल:`, error.message);
      }
    }
  }
}

सत्यापन उपकरण

छवि अखंडता सत्यापन

async function validateImage(filePath) {
  try {
    const metadata = await sharp(filePath).metadata();
    
    // मूल गुण जांचें
    if (!metadata.width || !metadata.height) {
      return { valid: false, error: 'आकार जानकारी गायब है' };
    }
    
    if (metadata.width <= 0 || metadata.height <= 0) {
      return { valid: false, error: 'अमान्य आकार' };
    }
    
    if (!metadata.format) {
      return { valid: false, error: 'प्रारूप जानकारी गायब है' };
    }
    
    // छवि प्रसंस्करण का प्रयास करें
    await sharp(filePath).resize(1, 1).toBuffer();
    
    return { valid: true, metadata };
  } catch (error) {
    return { valid: false, error: error.message };
  }
}

फ़ाइल आकार जांचना

const fs = require('fs');

function checkFileSize(filePath, maxSize = 10 * 1024 * 1024) { // 10MB
  const stats = fs.statSync(filePath);
  const sizeInMB = stats.size / (1024 * 1024);
  
  return {
    size: stats.size,
    sizeInMB,
    isValid: stats.size <= maxSize,
    maxSizeInMB: maxSize / (1024 * 1024)
  };
}

संबंधित लिंक

• Sharp कंस्ट्रक्टर
• छवि प्रसंस्करण API
• आउटपुट प्रारूप API
• मेटाडेटा API