c# - सी#का उपयोग कर एक छवि कैसे फसल करें?




image-processing (10)

bmp.SetResolution (image.HorizontalResolution, image। वर्टिकल रेसोल्यूशन) का उपयोग करें;

यह तब भी करना आवश्यक हो सकता है जब आप यहां सबसे अच्छा जवाब लागू करते हैं, खासकर यदि आपकी छवि असली है और संकल्प बिल्कुल 96.0 नहीं हैं

मेरा परीक्षण उदाहरण:

    static Bitmap LoadImage()
    {
        return (Bitmap)Bitmap.FromFile( @"e:\Tests\d_bigImage.bmp" ); // here is large image 9222x9222 pixels and 95.96 dpi resolutions
    }

    static void TestBigImagePartDrawing()
    {
        using( var absentRectangleImage = LoadImage() )
        {
            using( var currentTile = new Bitmap( 256, 256 ) )
            {
                currentTile.SetResolution(absentRectangleImage.HorizontalResolution, absentRectangleImage.VerticalResolution);

                using( var currentTileGraphics = Graphics.FromImage( currentTile ) )
                {
                    currentTileGraphics.Clear( Color.Black );
                    var absentRectangleArea = new Rectangle( 3, 8963, 256, 256 );
                    currentTileGraphics.DrawImage( absentRectangleImage, 0, 0, absentRectangleArea, GraphicsUnit.Pixel );
                }

                currentTile.Save(@"e:\Tests\Tile.bmp");
            }
        }
    }

मैं एक एप्लीकेशन कैसे लिख सकता हूं जो सी # में छवियों को फसल करेगा?



एक छवि फसल सी # में बहुत आसान है। हालांकि, सामानों को करने के लिए आप अपनी छवि की फसल का प्रबंधन कैसे करेंगे, यह थोड़ा कठिन होगा।

नीचे नमूना सी # में एक छवि को फसल करने का तरीका है।

var filename = @"c:\personal\images\horizon.png";
var img = Image.FromFile(filename);
var rect = new Rectangle(new Point(0, 0), img.Size);
var cloned = new Bitmap(img).Clone(rect, img.PixelFormat);
var bitmap = new Bitmap(cloned, new Size(50, 50));
cloned.Dispose();

केवल इस नमूना बिना किसी समस्या के काम कर रहा है:

var crop = new Rectangle(0, y, bitmap.Width, h);
var bmp = new Bitmap(bitmap.Width, h);
var tempfile = Application.StartupPath+"\\"+"TEMP"+"\\"+Path.GetRandomFileName();


using (var gr = Graphics.FromImage(bmp))
{
    try
    {
        var dest = new Rectangle(0, 0, bitmap.Width, h);
        gr.DrawImage(image,dest , crop, GraphicsUnit.Point);
        bmp.Save(tempfile,ImageFormat.Jpeg);
        bmp.Dispose();
    }
    catch (Exception)
    {


    }

}

मान लीजिए कि आप एक छवि फ़ाइल (जेपीईजी, बीएमपी, टीआईएफएफ, आदि) लेना चाहते हैं और इसे फसल करें, फिर इसे एक छोटी छवि फ़ाइल के रूप में सहेजें, मैं एक तृतीय पक्ष टूल का उपयोग करने का सुझाव देता हूं जिसमें .NET API है। यहां कुछ लोकप्रिय लोग हैं जिन्हें मैं पसंद करता हूं:

LeadTools
Accusoft पेगासस स्नोबाउंड इमेजिंग एसडीके


मैं नौकरी करने के लिए कोई अतिरिक्त मुक्ति के साथ एक आसान और तेज़ समारोह की तलाश में था। मैंने निक्स समाधान की कोशिश की, लेकिन मुझे एटलस फ़ाइल की 11 9 5 छवियों को निकालने के लिए 2 9, 4 सेकंड की आवश्यकता थी। तो बाद में मैंने इस तरह से काम किया और एक ही काम करने के लिए 2,43 सेकंड की जरूरत थी। शायद यह सहायक होगा।

// content of the Texture class
public class Texture
{
    //name of the texture
    public string name { get; set; }
    //x position of the texture in the atlas image
    public int x { get; set; }
    //y position of the texture in the atlas image
    public int y { get; set; }
    //width of the texture in the atlas image
    public int width { get; set; }
    //height of the texture in the atlas image
    public int height { get; set; }
}

Bitmap atlasImage = new Bitmap(@"C:\somepicture.png");
PixelFormat pixelFormat = atlasImage.PixelFormat;

foreach (Texture t in textureList)
{
     try
     {
           CroppedImage = new Bitmap(t.width, t.height, pixelFormat);
           // copy pixels over to avoid antialiasing or any other side effects of drawing
           // the subimages to the output image using Graphics
           for (int x = 0; x < t.width; x++)
               for (int y = 0; y < t.height; y++)
                   CroppedImage.SetPixel(x, y, atlasImage.GetPixel(t.x + x, t.y + y));
           CroppedImage.Save(Path.Combine(workingFolder, t.name + ".png"), ImageFormat.Png);
     }
     catch (Exception ex)
     {
          // handle the exception
     }
}

यह एक और तरीका है। मेरे मामले में मेरे पास है:

  • 2 संख्यात्मक अद्यतन नियंत्रण (जिसे वाममार्गिन और टॉपमार्गिन कहा जाता है)
  • 1 चित्र बॉक्स (चित्र बॉक्स 1)
  • 1 बटन जिसे मैंने जेनरेट किया था
  • सी पर 1 छवि: \ imagenes \ myImage.gif

बटन के अंदर मेरे पास यह कोड है:

Image myImage = Image.FromFile(@"C:\imagenes\myImage.gif");
Bitmap croppedBitmap = new Bitmap(myImage);
croppedBitmap = croppedBitmap.Clone(
            new Rectangle(
                (int)LeftMargin.Value, (int)TopMargin.Value,
                myImage.Width - (int)LeftMargin.Value,
                myImage.Height - (int)TopMargin.Value),
            System.Drawing.Imaging.PixelFormat.DontCare);
pictureBox1.Image = croppedBitmap;

मैंने सी # का उपयोग कर विजुअल स्टूडियो 2012 में इसे आजमाया। मुझे इस page से यह समाधान मिला


यह काफी आसान है:

  • फसल आकार के साथ एक नया Bitmap ऑब्जेक्ट बनाएं।
  • नए बिटमैप के लिए Graphics ऑब्जेक्ट बनाने के लिए Graphics.FromImage का उपयोग करें।
  • छवि को बिटमैप पर नकारात्मक एक्स और वाई समन्वय के साथ खींचने के लिए DrawImage विधि का उपयोग करें।

स्वीकार्य उत्तर से सरल यह है:

public static Bitmap cropAtRect(this Bitmap b, Rectangle r)
{
  Bitmap nb = new Bitmap(r.Width, r.Height);
  Graphics g = Graphics.FromImage(nb);
  g.DrawImage(b, -r.X, -r.Y);
  return nb;
}

और यह सबसे सरल उत्तर के " स्मृति से बाहर " अपवाद जोखिम से बचाता है।

संपादित करें : मुझे लगता है कि यह Bitmap.Save बचाए गए पीएनजी के साथ ठीक है। सहेजें या Paint.exe, लेकिन पेंट शॉप प्रो 6 द्वारा सहेजे गए पीएनजी के साथ विफल रहता है - सामग्री विस्थापित हो जाती है। GraphicsUnit.Pixel जोड़ा एक अलग गलत परिणाम देता है। शायद इन असफल पीएनजी दोषपूर्ण हैं।


आप ग्राफिक्स ऑब्जेक्ट को बिटमैप से ग्राफिक्स ऑब्जेक्ट पर फसल वाली छवि खींचने के लिए उपयोग कर सकते हैं।

Rectangle cropRect = new Rectangle(...);
Bitmap src = Image.FromFile(fileName) as Bitmap;
Bitmap target = new Bitmap(cropRect.Width, cropRect.Height);

using(Graphics g = Graphics.FromImage(target))
{
   g.DrawImage(src, new Rectangle(0, 0, target.Width, target.Height), 
                    cropRect,                        
                    GraphicsUnit.Pixel);
}






image-processing