अधिकतर सफेद स्थान छवियों को सहेजना - उच्च फ़ाइल आकार,

Question

कम करना चाहते हैं मैं कुछ ए 4 छवियों और छोटी छवियों को फ़ाइल में सहेज रहा हूं।

मैं जानना चाहता हूं कि सबसे अच्छा प्रारूप क्या है। वे एक स्कैन से वापस आते हैं जो केवल ग्रेस्केल है। हालांकि कुछ छवियां आकार में काफी बड़ी हैं (जो हम उम्मीद करेंगे) की तुलना में।

हमने उन्हें विभिन्न योग्यता के साथ जेपीईजी के रूप में सहेजने की कोशिश की है, लेकिन फिर भी उन्हें उतना छोटा नहीं मिल सकता जितना हम चाहते हैं, जेपीईजी इसके लिए सबसे प्रभावशाली प्रारूप नहीं है।

ए 4 सहेजी गयी गुणवत्ता 8 बजे 196KB के रूप में बचत है छोटे गुणवत्ता 8 में सहेजी गई छवि 28KB

के रूप में सहेज रहा है क्योंकि इस छवि के इतना सफेद स्थान हम बहुत छोटे फ़ाइल आकार की उम्मीद है। छवि गुणवत्ता की तुलना में फ़ाइल का आकार यहां अधिक महत्वपूर्ण है। क्या हम कुछ गलत कर रहे हैं?

यहाँ नमूना ए 4 छवि

यहाँ है नमूना छोटे छवि

हमारे कोड ग # में लिखा

// Get a bitmap. 
    Bitmap bmp1 = new Bitmap(@"c:\TestImageFromScanner.jpg"); 
    ImageCodecInfo jgpEncoder = GetEncoder(ImageFormat.Jpeg); 

    // Create an Encoder object based on the GUID 
    // for the Quality parameter category. 
    System.Drawing.Imaging.Encoder myEncoder = 
     System.Drawing.Imaging.Encoder.Quality; 

    // Create an EncoderParameters object. 
    // An EncoderParameters object has an array of EncoderParameter 
    // objects. In this case, there is only one 
    // EncoderParameter object in the array. 
    EncoderParameters myEncoderParameters = new EncoderParameters(1); 

    EncoderParameter myEncoderParameter = new EncoderParameter(myEncoder,8L); 
    myEncoderParameters.Param[0] = myEncoderParameter; 
    bmp1.Save(@"c:\TestJpegQuality8.jpg", jgpEncoder, myEncoderParameters); 

Answer 1

मैंने एक थ्रेसहोल्ड का उपयोग करके छवि को काले या सफेद में बदलने के लिए एक फ़ंक्शन का उपयोग किया था। इसने गुणवत्ता के साथ छवि आकार को बहुत कम कर दिया है जो काफी कम नहीं हुआ है।

var downsizeImage = ImageTools.ConvertToBitonal(scaledBmp, 500); 
        downsizeImage.Save(string.Format(@"C:\Temp\{0}Downsized.png", betSlipImage.BetSlipID), ImageFormat.Png); 
        var ms = new MemoryStream(); 
        downsizeImage.Save(ms, ImageFormat.Png); 

    public static Bitmap ConvertToBitonal(Bitmap original, int threshold) 
     { 
      Bitmap source; 

      // If original bitmap is not already in 32 BPP, ARGB format, then convert 
      if (original.PixelFormat != PixelFormat.Format32bppArgb) 
      { 
       source = new Bitmap(original.Width, original.Height, PixelFormat.Format32bppArgb); 
       source.SetResolution(original.HorizontalResolution, original.VerticalResolution); 

       using (var g = Graphics.FromImage(source)) 
       { 
        g.DrawImageUnscaled(original, 0, 0); 
       } 
      } 
      else 
      { 
       source = original; 
      } 

      // Lock source bitmap in memory 
      var sourceData = source.LockBits(new Rectangle(0, 0, source.Width, source.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); 

      // Copy image data to binary array 
      var imageSize = sourceData.Stride * sourceData.Height; 
      var sourceBuffer = new byte[imageSize]; 
      Marshal.Copy(sourceData.Scan0, sourceBuffer, 0, imageSize); 

      // Unlock source bitmap 
      source.UnlockBits(sourceData); 

      // Create destination bitmap 
      var destination = new Bitmap(source.Width, source.Height, PixelFormat.Format1bppIndexed); 
      destination.SetResolution(original.HorizontalResolution, original.VerticalResolution); 

      // Lock destination bitmap in memory 
      var destinationData = destination.LockBits(new Rectangle(0, 0, destination.Width, destination.Height), ImageLockMode.WriteOnly, PixelFormat.Format1bppIndexed); 

      // Create destination buffer 
      imageSize = destinationData.Stride * destinationData.Height; 
      var destinationBuffer = new byte[imageSize]; 

      var sourceIndex = 0; 
      var destinationIndex = 0; 
      var pixelTotal = 0; 
      byte destinationValue = 0; 
      var pixelValue = 128; 
      var height = source.Height; 
      var width = source.Width; 

      // Iterate lines 
      for (var y = 0; y < height; y++) 
      { 
       sourceIndex = y * sourceData.Stride; 
       destinationIndex = y * destinationData.Stride; 
       destinationValue = 0; 
       pixelValue = 128; 

       // Iterate pixels 
       for (var x = 0; x < width; x++) 
       { 
        // Compute pixel brightness (i.e. total of Red, Green, and Blue values) - Thanks murx 
        //       B        G        R 
        pixelTotal = sourceBuffer[sourceIndex] + sourceBuffer[sourceIndex + 1] + sourceBuffer[sourceIndex + 2]; 
        if (pixelTotal > threshold) 
        { 
         destinationValue += (byte)pixelValue; 
        } 
        if (pixelValue == 1) 
        { 
         destinationBuffer[destinationIndex] = destinationValue; 
         destinationIndex++; 
         destinationValue = 0; 
         pixelValue = 128; 
        } 
        else 
        { 
         pixelValue >>= 1; 
        } 
        sourceIndex += 4; 
       } 

       if (pixelValue != 128) 
       { 
        destinationBuffer[destinationIndex] = destinationValue; 
       } 
      } 

      // Copy binary image data to destination bitmap 
      Marshal.Copy(destinationBuffer, 0, destinationData.Scan0, imageSize); 

      // Unlock destination bitmap 
      destination.UnlockBits(destinationData); 

      // Dispose of source if not originally supplied bitmap 
      if (source != original) 
      { 
       source.Dispose(); 
      } 

      // Return 
      return destination; 
     } 

Answer 2

लेकिन वहाँ छवियों के लिए एक सबसे अच्छा छवि प्रारूप है जो ग्रेस्केल और अधिकतर सफेद जगह हैं?

आपकी छवि को देखते हुए यह मोनोक्रोम है, ग्रेस्केल नहीं। और यदि मोनोक्रोम स्वीकार्य है, तो आप अपने दस्तावेज़ों को संपीड़ित करने के लिए JBIG2 का उपयोग कर सकते हैं।

यह (अन्य बातों के अलावा) पाठ के लिए विशेष रूप से अनुकूलन है:

आदर्श रूप में, एक JBIG2 एनकोडर होगा खंड पाठ के क्षेत्रों, आंशिक रंग छवियों के क्षेत्रों, और अन्य डेटा के क्षेत्रों में इनपुट पेज। क्षेत्र जो न तो पाठ हैं और न ही आधे पत्थर हैं, आमतौर पर क्यूएम कोडर नामक संदर्भ-निर्भर अंकगणितीय कोडिंग एल्गोरिदम का उपयोग करके संपीड़ित होते हैं। पाठक क्षेत्रों को निम्नानुसार संपीड़ित किया जाता है: क्षेत्रों में अग्रभूमि पिक्सल को प्रतीकों में समूहीकृत किया जाता है। प्रतीकों का एक शब्दकोश तब बनाया जाता है और एन्कोड किया जाता है, आमतौर पर संदर्भ-निर्भर अंकगणितीय कोडिंग का भी उपयोग करता है, और क्षेत्रों को यह बताकर एन्कोड किया जाता है कि कौन से प्रतीक दिखाई देते हैं।

जोर मेरा।

Answer 3

फ्लैट रंग के बड़े ब्लॉक वाले चित्रों के लिए, पीएनजी -8 का उपयोग करने पर विचार करें।

हालांकि, इस मामले में ta.speot.ls का सुझाव ऐसा लगता है कि यह आपकी आवश्यकताओं को बेहतर तरीके से पूरा करेगा।

Answer 4

लापरवाह संपीड़न समूह एक ही रंग के पिक्सेल। यदि 100 सफेद पिक्सल हैं तो यह "सफेद पिक्सेल, सफेद पिक्सेल ....." के बजाय "सौ सफेद पिक्सल" स्टोर करता है।

आपकी छवियों में सफेद रंग के बड़े क्षेत्र हैं। यदि आप इसे अच्छी तरह से संपीड़ित करना चाहते हैं तो यह बिल्कुल सही सफेद होना चाहिए। तो अपनी छवियों को मापें। बस रंग की संख्या को कम करें।

मुझे लगता है कि आपको इसे किसी चीज़ के सबूत के रूप में पढ़ने योग्य होने की आवश्यकता है, इसलिए आपको ग्रेस्केल की आवश्यकता नहीं है।

सर्वोत्तम परिणाम 1 बिट गहराई (2 रंग काले और सफेद) होंगे, पीएनजी और टिफ अच्छे परिणाम देंगे।

यदि आप इस पर अधिक समय व्यतीत कर सकते हैं, तो आप अकेले पिक्सेल (शोर) को हटाने जैसे कुछ और प्रोसेसिंग कर सकते हैं।

जेपीईजी से बचें तस्वीरों के लिए बनाया गया था।