หมายเลขบทความ (Article ID): 319061 - รีวิวครั้งสุดท้าย: 13 มกราคม 2554 - Revision: 5.0

วิธีการบันทึกแฟ้มเป็น.gif กับตารางสีใหม่ โดยใช้ Visual c#

มุมมองแบบเคียงข้างกันคลิกที่นี่เพื่อแสดงบทความที่แปลโดยคอมพิวเตอร์และต้นฉบับภาษาอังกฤษเคียงข้างกัน
แปลโดยคอมพิวเตอร์คลิกที่นี่เพื่อดูข้อจำกัดความรับผิดชอบของ KB ที่แปลโดยคอมพิวเตอร์
ผลิตภัณฑ์ที่เกี่ยวข้องในบทความนี้
เคล็ดลับของระบบThis article applies to a different operating system than the one you are using. Article content that may not be relevant to you is disabled.

เนื้อหาบนหน้านี้

ขยายทั้งหมด | ยุบทั้งหมด

สรุป

การ CompuServe กราฟิก Interchange รูปแบบ (GIF) จะได้รับการออกแบบได้สูงสุด 256 สีที่มีการจัดเรียงในตารางสี เพื่อทำการแก้ไขทั่วไปแฟ้มรูปแบบ.gif คุณต้องเปลี่ยนตารางสีที่กำหนดเอง อย่างไรก็ตาม เมื่อSystem.Drawingการแก้ไขข้อรูปภาพวัตถุ และขอแล้วบันทึกรูปที่ มีการเข้ารหัสแฟ้ม GIF แฟ้ม.gif ที่เป็นผลลัพธ์ประกอบด้วยตารางสี halftone

เมื่อต้องการบันทึกเป็นรูปภาพมีตารางสีที่กำหนดเองโดยใช้ตัวเข้ารหัสแฟ้ม GIF คุณต้องทำกับสำเนา 256 สีรูปภาพที่System.Drawingยังไม่ถูกปรับเปลี่ยน

กลับไปด้านบน

การทำความเข้าใจเกี่ยวกับแฟ้ม.gif ที่กำลังเขียนโดยSystem.DrawingและGDI+

แฟ้มรูป.gif สามารถแสดงได้สูงสุด 256 สี เนื่องจากสี ทรัพยากร scarce ในแฟ้ม.gif, optimizing สีเหล่านั้นเป็นงานที่ร้องขอโดยทั่วไป เมื่อต้องการมีผลกับตารางมีสี optimized คุณต้องสามารถกำหนดตารางเองสีที่กำหนดเองใด ๆ ในแฟ้ม.gif

กระบวนการSystem.Drawingnamespace มี wrapper รอบ ๆ GDI + หลัก ดังนั้น บทความนี้อ้างถึง namespace ที่เป็น GDI + เว้นแต่ว่าลักษณะการทำงานที่มีเฉพาะSystem.Drawingnamespace มีสนทนา ในกรณีซึ่ง ระยะเวลาSystem.Drawingมีใช้

หลังจากที่ GDI + ปรับเปลี่ยนเป็นรูปภาพและมีการเขียนแล้วเกิดรูปเป็นแฟ้มโดยใช้ตัวเข้า GIF รหัส GDI + เขียนแฟ้ม โดยใช้สีแบบ halftone ที่นั้นรูปภาพบิตของวัตถุได้สีที่ลดลง GDI + ไม่มีการแปลงสีจากรูปแบบ 32 บิตต่อพิกเซล (32 BPP) เมื่อคุณเขียนรูปลงในแฟ้มได้เนื่องจากมีการจัดทำการปรับเปลี่ยนรูปแบบทั้งหมด ด้วย GDI + BPP 32 โปรแกรมกราฟิก

แม้ว่า GDI + สนับสนุนการสร้างรูปภาพและบิตแมปรูปแบบพิกเซลและสามารถแตกต่างกัน ดังนั้นการโหลดรูป.gif การใช้โปรแกรมการกราฟิก 32-BPP necessitates แปลง BPP 32 เมื่อปรับเปลี่ยน โดย GDI + อย่างไรก็ตาม การรูปภาพหรือบิตแมปนั่นคือไม่ปรับเปลี่ยนโดย GDI + retains พิกเซลที่จัดรูปแบบของต้นฉบับ และเขียนได้เพื่อใช้กับแฟ้มนั้นบันทึกวิธีการ ด้วยการเข้ารหัสที่เหมาะสม คุณสมบัตินี้เป็นข้อมูลพื้นฐานสำหรับเทคนิคหนึ่งที่สามารถบันทึกเป็นรูปภาพไปยังแฟ้ม.gif กับตารางสีที่กำหนดเอง

กลับไปด้านบน

การเขียน.gif แฟ้มกับตารางสีแบบกำหนดเอง

คุณสามารถเขียนข้อ unmodifiedบิตแมปมีการเข้ารหัสแฟ้ม GIF และเก็บไว้บิตแมปตารางสี intact ดังนั้นคุณสามารถใช้วิธีนี้จะบันทึกแฟ้ม.gif กับตารางสีใหม่ได้

วิธีการมีการ คัดลอกข้อมูลรูปภาพต้นฉบับรูปภาพวัตถุแบบ temporaryบิตแมปวัตถุ นี้ชั่วคราวบิตแมปมีสร้างเป็นการ 8-BPP จัดทำดัชนีไว้บิตแมปซึ่งเป็นรูปแบบพิกเซลที่ใช้ในการบันทึกแฟ้มเป็น.gif กระบวนการบิตแมปตารางสีถูกตั้งค่า โดยใช้การSetPaletteเมธอด และคำนิยามรูปถูกคัดลอกไปยัง temporaryบิตแมป. หลังจากที่คุณสร้าง temporaryบิตแมปมีคำนิยามที่ซ้ำกัน คุณสามารถใช้การSave()วิธีการบันทึก ด้วยการเข้ารหัสแฟ้ม GIF ซึ่งรักษาการเพื่อใช้ตารางสี BPP 8

เขียนเป็น.gif รูปไปยังแฟ้มที่มีตารางสีที่กำหนดเอง ดำเนินการดังต่อไปนี้:
  1. สร้างสำเนาบิตแมปวัตถุที่มีขนาดเท่ากันเป็นแหล่งที่มารูปภาพ.
  2. ตารางสีที่กำหนดเองของการตั้งค่านี้บิตแมปวัตถุตารางสีที่ต้องการ
  3. ใช้แบบLockBitsวิธีการเข้าถึงบิตรูปของสำเนาการเขียน
  4. สร้างรูป view definition ในการคัดลอก โดยการเขียนดัชนีสีหน่วยความจำที่ได้รับจากLockBitsซึ่งทำสำเนาพิกเซลในต้นฉบับรูปภาพ.
  5. การใช้UnLockBitsการปลดปล่อยบิตรูป
  6. ใช้แบบบิตแมปคัดลอกกับตารางสีที่กำหนดเองเพื่อบันทึกการรูปภาพไปยังแฟ้มโดยใช้บันทึกและตัวเข้ารหัสแฟ้ม GIF
  7. ออกแบบบิตแมปการคัดลอกของรูปภาพ.
กลับไปด้านบน

การใช้รหัสตัวอย่าง

ตัวอย่างรหัสในบทความนี้อธิบายวิธีการใช้Bitmap.Saveเมื่อต้องการเขียนแฟ้ม.gif กับตารางสีที่กำหนดเองของขนาดที่โปรแกรม รับการออกรหัสคือไม่แบบสำหรับประสิทธิภาพการทำงานได้เนื่องจากวัตถุประสงค์ของที่อยู่สำหรับการสาธิตเท่านั้น โอกาสที่ดีที่สุดสำหรับการปรับให้เหมาะสมเป็นพิกเซลที่ loops การประมวลผลGetPixelabstraction ที่สะดวกของรูปแบบพิกเซล แต่มันอยู่ remarkably ช้า ตัวอย่างรหัสจะเร็วมากถ้าคุณใช้LockBitsการเข้าถึงแบบพิกเซลโดยตรง เมื่อต้องการเพิ่มความเร็ว ไม่ใช้การGetPixelวิธีการ และสีคลา abstraction การปรับปรุงประสิทธิภาพ เขียนแปลง grayscale โดยใช้จำนวนเต็มคณิตศาสตร์ มากกว่าลอยจุด

ฟังก์ชันตัวอย่างใช้พารามิเตอร์ทั้งสี่ต่อไปนี้:
  • ใด ๆ GDI +รูปภาพวัตถุ
  • ชื่อแฟ้มสำหรับแฟ้มเป้าหมาย
  • หมายเลขของสีสำหรับแฟ้ม.gif
  • ค่าสถานะที่ระบุว่า จะต้องเป็นสีโปร่งใส
สร้างฟังก์ชันแรกเป็นบิตแมปวัตถุที่มีรูปแบบพิกเซลของPixelFormat.Format8BPPIndexedเนื่องจากมีวัตถุที่ถูกบันทึกไว้ในการสร้างแฟ้ม.gif ที่มีnColors. ขั้นตอนถัดไป สร้างการจานสี ด้วยสีที่กำหนดเอง แฟ้ม.gif ที่ได้รับขนาดและรายการที่ระบุสำหรับตารางของสีจากนั้นบิตแมปของวัตถุColorPalette. ตัวอย่างรหัสสร้างมาตราส่วนเป็นสีเทาสำหรับวัตถุประสงค์ในการสาธิตได้เนื่องจากอัลกอริทึมที่ง่ายต่อการขยายผ่านขนาดตารางสีต่าง ๆ

เมื่อต้องการสร้างแฟ้ม.gif คุณต้องเริ่มต้น BPP 8บิตแมปวัตถุที่ มีคำนิยามรูปที่จะสามารถเขียนไปยังแฟ้ม ในตัวอย่างรหัส ชุดงานกลาง loops ถูกใช้ในการแปลงสีรูปขาเข้าไปเป็น essentially แบบขาวดำโทรทัศน์พื้นที่สี

เข้าถึงสำหรับวัตถุประสงค์ในการสาธิต พิกเซลของรูปภาพต้นฉบับจะได้โดยใช้ความของGetPixel()วิธีการบิตแมปวัตถุที่มีสำเนาของรูปต้นฉบับ aบิตแมปทำการคัดลอกเนื่องจากการรูปภาพไม่มีใช้คลาGetPixel()วิธีการ

คุณสามารถใช้เทคนิคอื่น ๆ พิกเซล เช่นการเข้าถึงโดยตรงพิกเซลโดยใช้การเข้าถึงLockBits()เมธอดหรือ interop ด้วยรหัสที่ไม่มีการจัดการมาตรฐานโดยการใช้ส่วน DIB GDI ของ windows. เมื่อคุณใช้การBitBltฟังก์ชันเพื่อคัดลอกบิตแมปจากแบบ HDC Gdi + GDI DIB Section ตัวควบคุมโดเมนของหน่วยความจำGBitBltฟังก์ชันใช้สี abilities ของ GDI ที่ตรงกัน

หลังจากที่คุณสร้างการบิตแมปคัดลอก ใช้บันทึกวิธีการด้วยการImageFormat.Gifวัตถุการเขียนบิตแมปนั้นไปยังแฟ้มเป้าหมาย



กลับไปด้านบน

แฟ้ม gif ที่ มีน้อยกว่า 256 สี

ตัวแปลงสัญญาณ GIF ใน GDI + รุ่น 1.0 encodes เฉพาะ GDI +รูปภาพที่อยู่การ BPP 8 อื่น ๆ ทั้งหมดรูปภาพรูปแบบจะถูกแปลงก่อนที่จะเข้ารหัส รหัสนี้ใช้ BPP 8บิตแมปรูปแบบการเขียนแฟ้ม.gif ที่มีน้อยกว่า 256 สีเนื่องจากตัวแปลงสัญญาณ GIF รู้จัก BPP 8บิตแมปวัตถุที่ประกอบด้วยน้อยกว่า 256 สีตามPalette.Countคุณสมบัติ

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับตัวแปลงสัญญาณ GIF ให้ดู "อ้างอิง:"ส่วนของบทความนี้

แต่ColorPaletteคลาสของSystem.Drawingnamespace ใน.NET Framework ไม่สามารถถูก instantiated ขึ้นอยู่กับบิตแมปวัตถุ ซึ่งจะจำกัดนั่นเท่านั้นSystem.Drawing.Bitmapคลา imposes ใน.NET Framework อย่างไรก็ตาม การใช้วิธีการในบทความนี้บิตแมปวัตถุต้องมีใหม่ColorPaletteวัตถุที่ประกอบด้วยสีที่น้อยกว่าค่าเริ่มต้น 256ColorPalette.

เพื่อให้ได้ ตัวอย่างรหัสกำหนดชื่อฟังก์ชันGetColorPalette. ฟังก์ชันนี้สร้าง temporary เป็นบิตแมปวัตถุที่มีความละเอียดของสีใกล้กับตัวเลขที่ถูกต้องที่ร้องขอของสี ฟังก์ชันการอ้างอิงแล้วนี้จานสีคุณสมบัติ และกลับไปยังผู้เรียก ซึ่งสร้างใหม่ColorPaletteด้วยสีที่เป็นไปได้หลายอย่างใดอย่างหนึ่งนับ: 256 สี สี 16 หรือสีที่สอง (ขาวดำ) แม้ว่าคุณสามารถสร้างตารางของสีในแฟ้ม.gif ที่มีขนาดเล็กกว่า 256 สี ตารางสีมีขนาดที่มีการใช้พลังงานของสองเพียงอย่างเดียว

เมื่อคุณจำกัดขนาดตารางสีเมื่อต้องการพลังงานของสอง ลดเนื้อที่ที่สิ้นเปลือง ตารางสีได้ในตัวอย่างนี้เป็นสีที่ 8 (2 x 2 x 2) ด้วยตัวอย่างรหัส แฟ้ม.gif จะถูกสร้างพร้อมกับตารางสี 16 สีได้เนื่องจากที่น้อยที่สุดPixelFormatสำหรับคำบิตแมปสีที่ accomodates หก

รหัสในการวนรอบของกระบวนการที่คัดลอกคำนิยามของพิกเซลของรูปภาพเพื่อ BPP 8บิตแมปจะเป็นบัญชีขนาดของชุดแบบสีเมื่อรหัสค่าดัชนีของพิกเซลที่คำนวณ ตัวแปลงสัญญาณ GIF จำกัดขนาดของชุดแบบสี และจำกัดคำนิยามรูปเป็นค่าดัชนีที่เข้ากันได้กับขนาดของชุดแบบสี (นั่นคือ อาจเกิดขึ้น GIF สีตาราง), และสามารถจึงสร้างแฟ้ม.gif ที่ มีน้อยกว่า 256 สี

กลับไปด้านบน

โปร่งใส gif

ในตัวอย่างรหัส การColorPaletteขั้นตอนการสร้างการตั้งค่าจากรายการแรกเป็น สีโปร่งใส GIF เพื่อแสดงให้เห็นถึงการใช้คุณลักษณะความโปร่งใส รหัสไม่นี้ โดยการตั้งค่าคอมโพเนนต์ Alpha ของสีรายการเป็นศูนย์ ตัวอย่างรหัสในบทความนี้มีไว้สำหรับการสาธิตเท่านั้น ดังนั้น สีโปร่งใสมีทางเลือกเอง และอาจมีผลลัพธ์ที่ไม่คาดคิดที่ขึ้นกับแหล่งที่มาทั้งหมดรูปภาพ.

สีแรกในการระบุตัวเข้ารหัสแฟ้ม GIFColorPaletteที่มีค่า Alpha ของศูนย์เป็นสีโปร่งใส ซึ่งหมายความ ว่า สีโปร่งใสไม่มีเป็น รายการแรกในการColorPalette. คุณสามารถเป็นหนึ่งสามารถ 256 สีของชุดแบบสี on condition ว่ารายการ preceeding ทั้งหมดที่ประกอบด้วยคอมโพเนนต์ Alpha ด้วยค่าที่ไม่ใช่ศูนย์ รายการใด ๆ ในภายหลัง โดยค่าคอมโพเนนต์ Alpha ของศูนย์จะถูกละเว้น รายการทั้งหมดที่มีคอมโพเนนต์ของ Alpha ใช่ศูนย์จะพิจารณา opaque

กลับไปด้านบน

แฟ้ม GIF/LZW ที่อนุญาตให้ใช้สิทธิ์ของประเด็น

Microsoft ยังได้รับใบอนุญาตจาก Unisys ใช้รูปแบบแฟ้ม.gif และเทคโนโลยีอื่น ๆ LZW ที่ครอบคลุม โดย Unisys เจ้าของสหรัฐอเมริกาและสิทธิบัตรต่างประเทศในหมายเลขผลิตภัณฑ์ของ Microsoft อย่างไรก็ตาม สิทธิ์การใช้งานนี้ไม่ขยายให้นักพัฒนาอื่น ๆ ที่ใช้ Microsoft พัฒนาผลิตภัณฑ์หรือ toolkits พัฒนาแอปพลิเคชัน เป็นนักพัฒนาของบริษัทอื่น คุณจำเป็นต้องตรวจสอบว่า คุณต้องขอรับใบอนุญาตจาก Unisys ใช้รูปแบบ.gif หรือเทคโนโลยี LZW

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับสิทธิ์การใช้งาน LZW และ GIF คลิกหมายเลขบทความด้านล่างนี้เพื่อดูบทความในฐานความรู้ของ Microsoft:
193543  (http://support.microsoft.com/kb/193543/EN-US/ ) ข้อมูล: Unisys GIF และข้อมูลสิทธิ์การใช้งานเทคโนโลยี LZW

กลับไปด้านบน

ตัวอย่างรหัส

protected ColorPalette GetColorPalette( uint nColors )
{
    // Assume monochrome image.
    PixelFormat     bitscolordepth = PixelFormat.Format1bppIndexed;
    ColorPalette    palette;    // The Palette we are stealing
    Bitmap          bitmap;     // The source of the stolen palette

    // Determine number of colors.
    if (nColors > 2)
        bitscolordepth = PixelFormat.Format4bppIndexed;
    if (nColors > 16)
        bitscolordepth = PixelFormat.Format8bppIndexed;

    // Make a new Bitmap object to get its Palette.
    bitmap = new Bitmap( 1, 1, bitscolordepth );

    palette = bitmap.Palette;   // Grab the palette
    
    bitmap.Dispose();           // cleanup the source Bitmap

    return palette;             // Send the palette back
}

				
protected void SaveGIFWithNewColorTable(
    Image       image,
    string      filename,
    uint        nColors,
    bool        fTransparent
    )
{

    // GIF codec supports 256 colors maximum, monochrome minimum.
    if (nColors > 256)
        nColors = 256;
    if (nColors < 2)
        nColors = 2;

    // Make a new 8-BPP indexed bitmap that is the same size as the source image.
    int   Width = image.Width;
    int   Height = image.Height;

    // Always use PixelFormat8bppIndexed because that is the color
    // table-based interface to the GIF codec.
    Bitmap  bitmap = new Bitmap(Width, 
                            Height, 
                            PixelFormat.Format8bppIndexed); 

    // Create a color palette big enough to hold the colors you want.
    ColorPalette pal = GetColorPalette(nColors);

    // Initialize a new color table with entries that are determined
    // by some optimal palette-finding algorithm; for demonstration 
    // purposes, use a grayscale.
    for (uint i = 0; i < nColors; i++)
    {
        uint Alpha = 0xFF;                      // Colors are opaque.
        uint Intensity = i*0xFF/(nColors-1);    // Even distribution. 

        // The GIF encoder makes the first entry in the palette
        // that has a ZERO alpha the transparent color in the GIF.
        // Pick the first one arbitrarily, for demonstration purposes.

        if ( i == 0 && fTransparent) // Make this color index...
            Alpha = 0;          // Transparent
    
        // Create a gray scale for demonstration purposes.
        // Otherwise, use your favorite color reduction algorithm
        // and an optimum palette for that algorithm generated here.
        // For example, a color histogram, or a median cut palette.
        pal.Entries[i] = Color.FromArgb( (int)Alpha, 
                                        (int)Intensity, 
                                        (int)Intensity, 
                                        (int)Intensity );
    }

    // Set the palette into the new Bitmap object.
    bitmap.Palette = pal;


    // Use GetPixel below to pull out the color data of Image.
    // Because GetPixel isn't defined on an Image, make a copy 
    // in a Bitmap instead. Make a new Bitmap that is the same size as the
    // image that you want to export. Or, try to
    // interpret the native pixel format of the image by using a LockBits
    // call. Use PixelFormat32BppARGB so you can wrap a Graphics  
    // around it.
    Bitmap BmpCopy = new Bitmap(Width, 
                            Height, 
                            PixelFormat.Format32bppArgb); 
    {
        Graphics g = Graphics.FromImage(BmpCopy);

        g.PageUnit = GraphicsUnit.Pixel;

        // Transfer the Image to the Bitmap
        g.DrawImage(image, 0, 0, Width, Height);

        // g goes out of scope and is marked for garbage collection.
        // Force it, just to keep things clean.
        g.Dispose();
    }

    // Lock a rectangular portion of the bitmap for writing.
    BitmapData  bitmapData;
    Rectangle   rect = new Rectangle(0, 0, Width, Height);

    bitmapData = bitmap.LockBits(
        rect,
        ImageLockMode.WriteOnly,
        PixelFormat.Format8bppIndexed);

    // Write to the temporary buffer that is provided by LockBits.
    // Copy the pixels from the source image in this loop.
    // Because you want an index, convert RGB to the appropriate
    // palette index here.
    IntPtr pixels = bitmapData.Scan0;

    unsafe 
    { 
        // Get the pointer to the image bits.
        // This is the unsafe operation.
        byte *  pBits;
        if (bitmapData.Stride > 0)
            pBits = (byte *)pixels.ToPointer();
        else
            // If the Stide is negative, Scan0 points to the last 
            // scanline in the buffer. To normalize the loop, obtain
            // a pointer to the front of the buffer that is located 
            // (Height-1) scanlines previous.
            pBits = (byte *)pixels.ToPointer() + bitmapData.Stride*(Height-1);
        uint stride = (uint)Math.Abs(bitmapData.Stride);

        for ( uint row = 0; row < Height; ++row )
        {
            for ( uint col = 0; col < Width; ++col )
            {
                // Map palette indexes for a gray scale.
                // If you use some other technique to color convert,
                // put your favorite color reduction algorithm here.
                Color     pixel;    // The source pixel.

                // The destination pixel.
                // The pointer to the color index byte of the
                // destination; this real pointer causes this
                // code to be considered unsafe.
                byte *    p8bppPixel = pBits + row*stride + col;

                pixel = BmpCopy.GetPixel((int)col, (int)row);

                // Use luminance/chrominance conversion to get grayscale.
                // Basically, turn the image into black and white TV.
                // Do not calculate Cr or Cb because you 
                // discard the color anyway.
                // Y = Red * 0.299 + Green * 0.587 + Blue * 0.114

                // This expression is best as integer math for performance,
                // however, because GetPixel listed earlier is the slowest 
                // part of this loop, the expression is left as 
                // floating point for clarity.

                double luminance = (pixel.R *0.299) +
                    (pixel.G *0.587) +
                    (pixel.B *0.114);

                // Gray scale is an intensity map from black to white.
                // Compute the index to the grayscale entry that
                // approximates the luminance, and then round the index.
                // Also, constrain the index choices by the number of
                // colors to do, and then set that pixel's index to the 
                // byte value.
                *p8bppPixel = (byte)(luminance * (nColors-1)/255 +0.5);

            } /* end loop for col */ 
        } /* end loop for row */ 
    } /* end unsafe */ 

    // To commit the changes, unlock the portion of the bitmap.  
    bitmap.UnlockBits(bitmapData);

    bitmap.Save(filename, ImageFormat.Gif);

    // Bitmap goes out of scope here and is also marked for
    // garbage collection.
    // Pal is referenced by bitmap and goes away.
    // BmpCopy goes out of scope here and is marked for garbage
    // collection. Force it, because it is probably quite large.
    // The same applies to bitmap.
    BmpCopy.Dispose();
    bitmap.Dispose();

}

เกี่ยวกับรหัสตัวอย่าง

Microsoft ให้ตัวอย่างการเขียนโปรแกรมสำหรับภาพเท่านั้น โดยไม่มีการรับประกันแสดง หรือ อื่น รวม แต่ไม่จำกัดเพียงการ การรับประกันโดยนัยของสามารถเชิงพาณิชย์และ/หรือความเหมาะสมสำหรับวัตถุประสงค์เฉพาะ บทความนี้อนุมานว่า คุณไม่คุ้นเคยกับภาษาการเขียนโปรแกรมที่มีการแสดงและเครื่องมือที่ใช้ในการสร้าง และขั้นตอนการตรวจแก้จุดบกพร่อง ผู้เชี่ยวชาญฝ่ายสนับสนุนของ Microsoft สามารถช่วยอธิบายฟังก์ชันการทำงานของกระบวนการเฉพาะ แต่พวกเขาจะปรับเปลี่ยนตัวอย่างเหล่านี้เพื่อให้มีเพิ่มฟังก์ชันการทำงาน หรือสร้างกระบวนการตามที่คุณต้องการไม่
ถ้าคุณได้รับการจำกัดประสบการณ์ในการเขียนโปรแกรม คุณอาจต้องติดต่อคู่ค้ารับรองของ Microsoft หรือคำแนะนำบริการของ Microsoft สำหรับข้อมูลเพิ่มเติม โปรดไปที่เว็บไซต์ของ Microsoft เหล่านี้:

Microsoft ที่คู่ค้า - รับรองhttps://partner.microsoft.com/global/30000104 (https://partner.microsoft.com/global/30000104)

บริการคำแนะนำของ Microsoft-http://support.microsoft.com/gp/advisoryservice (http://support.microsoft.com/gp/advisoryservice)

สำหรับข้อมูลเพิ่มเติม เกี่ยวกับตัวเลือกการสนับสนุนที่มีอยู่ และ เกี่ยวกับวิธีการติดต่อ Microsoft แวะไปที่เว็บไซต์ต่อไปนี้ของ Microsoft:http://support.microsoft.com/default.aspx?scid=fh;EN-US;CNTACTMS (http://support.microsoft.com/default.aspx?scid=fh;EN-US;CNTACTMS)
กลับไปด้านบน

การแก้ไขปัญหา

เมื่อคุณใช้รหัสนี้จะเขียนทับแฟ้มมีอยู่ คุณอาจเห็นสิ่งที่ดูเหมือนมีปัญหากับขนาดของแฟ้มที่เป็นผลลัพธ์ ปัญหานี้เกิดขึ้นเนื่องจากการเป็นปัญหาที่เกิดขึ้นใน GDIPlus รุ่น 1.0 ที่ตัดทอนแฟ้มไม่ สำหรับข้อมูลเพิ่มเติมเกี่ยวกับขนาดแฟ้มของรูป ให้ดู"การอ้างอิง"ส่วน

ตัวอย่างรหัสที่ยังใช้คำสำคัญไม่ปลอดภัย. จะทำนี้ได้เนื่องจากรหัสที่ย้ายข้อกำหนดของพิกเซลจากแหล่งบิตแมปไปยังปลายทางบิตแมป เป็นตัวชี้ไปที่ใช้ไบต์ค่าต่างๆ: ตัวชี้จริงสามารถใช้ได้เฉพาะในโค้ดที่ถูกทำเครื่องหมายไม่ปลอดภัย และการคอมไพล์ด้วย/ ไม่ปลอดภัยตัวเลือกของคอมไพเลอร์ รหัสใด ๆ ที่เขียนด้วยวิธีนี้มีการรักษาความปลอดภัย impliciations โดยเฉพาะ เช่นรหัสที่ได้รับการจัดการอาจมีการร้องขอสิทธิ์ และอาจล้มเหลวให้ทำงานหากคุณไม่เชื่อถือได้

กลับไปด้านบน

ข้อมูลอ้างอิง

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับรูปแบบพิกเซลของตัวแปลงสัญญาณ GIF คลิกหมายเลขบทความด้านล่างนี้เพื่อดูบทความในฐานความรู้ของ Microsoft:
318343  (http://support.microsoft.com/kb/318343/EN-US/ ) ข้อมูล: แฟ้ม GIF GDI + ถูกบันทึกไว้โดยใช้การจัดรูปแบบ BPP 8
สำหรับข้อมูลเพิ่มเติมเกี่ยวกับขนาดแฟ้มของรูป คลิกหมายเลขบทความด้านล่างนี้เพื่อดูบทความในฐานความรู้ของ Microsoft:
312119  (http://support.microsoft.com/kb/312119/EN-US/ ) PRB: วิธีการบันทึกของคลาบิตแมปไม่ตัดขนาดของแฟ้ม

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับเทคนิคนี้ใช้ Microsoft ในการ Visual c ++ คลิกหมายเลขบทความด้านล่างนี้เพื่อดูบทความในฐานความรู้ของ Microsoft:
315780  (http://support.microsoft.com/kb/315780/EN-US/ ) HOWTO: บันทึกแฟ้ม GIF ที่ มีสีเป็นตารางใหม่ โดยใช้ GDI +
กลับไปด้านบน

อภิธานศัพท์

bpp
บิตต่อพิกเซล - จำนวนบิตใช้เพื่อแสดงค่าสีของแต่ละพิกเซลในรูปแบบ digitized อธิบายโครงร่างทางกายภาพของพิกเซลแต่ละคำจำกัดความของสีในรูปภาพ รูปแบบพิกเซลที่พบโดยทั่วไป และการอ้างอิง generically รวม BPP 32, 24 BPP, BPP 16, BPP 8, BPP 4, BPP 1
8 bpp
รูปพิกเซลรูปที่แสดงเป็น 8 บิตที่มีอยู่ในหนึ่งไบต์ The byte value is used as an index into a color table that contains the actual red-green-blue (RGB) color definitions. Because the index is one byte in size, the color table is limited to 256 colors.
GIF
Graphics Interchange Format - a streamable image file format that was created by CompuServe.
RGB
Red, green and blue - each commonly expressed as a byte, and resulting in a color 3-byte triplet.

กลับไปด้านบน
ใช้กับ
  • Microsoft .NET Framework Software Development Kit 1.0
  • Microsoft Visual C# .NET 2002 Standard Edition
  • Microsoft Visual C# 2005 Express Edition
  • Microsoft Windows XP Professional Edition
กลับไปด้านบน
Keywords: 
kbdswgdi2003swept kbhowtomaster kbmt KB319061 KbMtth
กลับไปด้านบน
แปลโดยคอมพิวเตอร์แปลโดยคอมพิวเตอร์
ข้อมูลสำคัญ: บทความนี้แปลโดยซอฟต์แวร์การแปลด้วยคอมพิวเตอร์ของ Microsoft แทนที่จะเป็นนักแปลที่เป็นบุคคล Microsoft มีบทความที่แปลโดยนักแปลและบทความที่แปลด้วยคอมพิวเตอร์ เพื่อให้คุณสามารถเข้าถึงบทความทั้งหมดในฐานความรู้ของเรา ในภาษาของคุณเอง อย่างไรก็ตาม บทความที่แปลด้วยคอมพิวเตอร์นั้นอาจมีข้อบกพร่อง โดยอาจมีข้อผิดพลาดในคำศัพท์ รูปแบบการใช้ภาษาและไวยากรณ์ เช่นเดียวกับกรณีที่ชาวต่างชาติพูดผิดเมื่อพูดภาษาของคุณ Microsoft ไม่มีส่วนรับผิดชอบต่อความคลาดเคลื่อน ความผิดพลาดหรือความเสียหายที่เกิดจากการแปลเนื้อหาผิดพลาด หรือการใช้บทแปลของลูกค้า และ Microsoft มีการปรับปรุงซอฟต์แวร์การแปลด้วยคอมพิวเตอร์อยู่เป็นประจำ
ต่อไปนี้เป็นฉบับภาษาอังกฤษของบทความนี้:319061  (http://support.microsoft.com/kb/319061/en-us/ )
กลับไปด้านบน