Delphi转换图形为pcx格式->C#转换图形为pcx格式

最新推荐文章于 2021-03-11 21:57:38 发布
最新推荐文章于 2021-03-11 21:57:38 发布
阅读量381 收藏
点赞数

        以下为一段转换图形为pcx的Delphi代码，需要转成C#代码，希望懂Delphi和C#的帮个忙转换一下。万分的感激。(后面附Delphi的源码下载。)

unit PCX;

interface

Uses
   Windows, Classes, Graphics;
{
{ Setup the following variable before calling LoadFromFileX
{
{ Global_KeepTrueFormat:Word
{ 0 = Use the files native bits per pixel for the TBitMap
{ 1 = Force TBitMap of 256 colors and use gray it file was 24bit
{ 2 = Force TBitMap to 24bit
{
{ SAVETOFILEX(parm1,parm2,parm3);
{    Parm1=Filename
{    Parm2=TBitMap to save
{    Parm3=Type of PCX file to create
{           1 = Save as 256 Color file
{           2 = Save as 16M file
{
{ ****************** ERROR HANDLING ******************
{ If you want a special message displayed if there is an error
{ while saving a PCX, then search for    ###ERROR###    and you will
{ find the block of code that has nothing in it currently. Just put in
{ whatever logic you like. For example: An error message :)
}

Procedure LoadFromFileX(FileName:String;Const BitMap:TBitMap);
Procedure SaveToFileX(FileName:String;Const BitMap:TBitMap;PcxType:Byte);

implementation

Type
   TypeRegVer=Set Of (Non_Registered,Registered,OEM,PRO,SYSOP);
   DataLineArray=Array[0..65535] Of Byte;
   DataWordArray=Array[0..65535] Of SmallInt;
   FakePalette= Packed Record
      LPal : TLogPalette;
      Dummy:Array[1..255] of TPaletteEntry;
      End;

   TypeEgaPalette=Array[0..16] Of Byte;
   TypePalette=Array[0..255,1..3] Of Byte;

Const
   Global_HiColor=3;
   Global_KeepTrueFormat:Word=0;

   Global_PaletteDef:Array[0..15,1..3] Of Byte = (
{Black}                                       (0  ,0  ,0 ),
{Blue}                                        (0  ,0  ,32),
{Green}                                       (0  ,32 ,0 ),
{Cyan}                                        (0  ,32 ,32),
{Red}                                         (32 ,0  ,0 ),
{Magenta}                                     (32 ,0  ,32),
{Brown}                                       (32 ,32 ,0 ),
{Light Gray}                                  (42 ,42 ,42),
{Dark Gray}                                   (21 ,21 ,21),
{Light Blue}                                  (0  ,0  ,63),
{Light Green}                                 (0  ,63 ,0 ),
{Light Cyan}                                  (0  ,63 ,63),
{Light Red}                                   (63 ,0  ,0 ),
{Light Magenta}                               (63 ,0  ,63),
{Yellow}                                      (63 ,63 ,0 ),
{Bright White}                                (63 ,63 ,63)
                                              );

Var
  PictureFile:File;
  PaletteVGA:TypePalette;
  SysPal:FakePalette;
  TempArrayD:^DataLineArray;
  TempArrayD2:^DataLineArray;
  TempArrayDBIg,TempArrayDBig16:^DataLineArray;
  ErrorString:ShortString;
  Width:Word;
  Height:Word;
  BitsPerPixel:SmallInt;
  MyKeepTrueFormat:Boolean;
  MyKeepTrueBits:Word;
Var
  PcxVersion:Word;
  PcxColorPlanes:Byte;
  PcxEncoding:Word;
  PcxBytesPerLine:Word;
  PcxPaletteType:Word;

Const
  Index1:Word=0;
  Index2:Word=0;
  Const4096=8*1024;
Var
  IndexData:Array[0..Const4096-1] Of Byte;
Procedure FileGetMore;
Var
  NumRead:Integer;
Begin
FillChar(IndexData,Const4096,0);
BlockRead(PictureFile,IndexData,Const4096,NumRead);
Index1:=Const4096;
Index2:=0;
End;

Procedure FastGetBytes(Var Ptr1;NumBytes:Word);
Var
  X:Integer;
Begin
{
{ If we have enough the block it!
{ Otherwise do one at a time!
}
If Index1<NumBytes Then
   Begin
   If Index1=0 Then
      Begin
      FileGetMore;
      End;
   For X:=0 To NumBytes-1 Do
       Begin
       DataLineArray(Ptr1)[X]:=IndexData[Index2];
       Inc(Index2);
       Dec(Index1);
       If Index1=0 Then
          FileGetMore;
       End;
   End
Else
   Begin
   {
   { Block it fast!
   }
   Move(IndexData[Index2],DataLineArray(Ptr1)[0],NumBytes);
   Index2:=Index2+Numbytes;
   Index1:=Index1-NumBytes;
   End;
End;

Function FastGetByte:Byte;
Begin
If Index1=0 Then
   Begin
   FileGetMore;
   End;
FastGetByte:=IndexData[Index2];
Inc(Index2);
Dec(Index1);
End;

Function FastGetWord:Word;
Begin
FastGetWord:=Word(FastGetByte)+Word(FastGetByte)*256;
End;

Procedure FileIoReset;
Begin
Index1:=0;
Index2:=0;
End;

Procedure OpenFile(Var FileName:String;Var FileOk:Boolean);
Var
  Io:Integer;
  OldFileMode:Word;
Begin
FileIoReset;
OldFileMode:=FileMode;
FileMode:=0;
AssignFile(PictureFile,FileName);
ReSet(PictureFile,1);
Io:=IoResult;
If Io<>0 Then
   Begin
   FileOk:=False;
   End;
FileMode:=OldFileMode;
End;

Procedure FillerUp(Var TempArrayD;Size:Word;B1:Byte);
Begin
FillChar(TempArrayD,Size,B1);
End;

Procedure ConvertXBitsToYBits(Var Input,Output:DataLineArray;Xbits,Ybits,Width:Word);
Var
  X,Z:Word;
  B1:Byte;
Begin
{
{ Generic converter to a single data line :)
{ Can go only from smaller bits to larger bits, otherwise you need to
{     dither down!
{ PaletteVGA MUST be setup already!
}
Case Xbits Of
     1:Begin
       Case Ybits Of
            4:Begin
              {
              { From 1 bit to 4 bit, hmmmmm EZ :)
              }
              For X:=0 To Width-1 Do
                  Begin
                  B1:=(Input[X Shr 3] Shr (7-(X Mod 8))) And 1;
                  OutPut[X Shr 1]:=OutPut[X Shr 1] Or (B1 Shl ((1-(X Mod 2))*4));
                  End;
              End;
            8:Begin
              {
              { From 1 bit to 8 bit, hmmmmm EZ :)
              }
              For X:=0 To Width-1 Do
                  Begin
                  B1:=(Input[X Shr 3] Shr (7-(X Mod 8) )) And 1;
                  OutPut[X]:=B1;
                  End;
              End;
           24:Begin
              {
              { From 1 bit to 8 bit, hmmmmm EZ :)
              }
              Z:=0;
              For X:=0 To Width-1 Do
                  Begin
                  B1:=((Input[X Shr 3] Shr (7-(X Mod 8))) And 1)*255;
                  OutPut[Z+0]:=B1;
                  OutPut[Z+1]:=B1;
                  OutPut[Z+2]:=B1;
                  Z:=Z+3;
                  End;
              End;
           End;
       End;
     4:Begin
       Case Ybits Of
            4:Begin
              Move(Input[0],Output[0],Width);
              End;
            8:Begin
              {
              { Go from 4 bits to 8 bit :)
              }
              For X:=0 To Width-1 Do
                  Begin
                  B1:=(Input[X Shr 1] Shr ((1-(X Mod 2))*4)) And $0F;
                  OutPut[X]:=B1;
                  End;
              End;
           24:Begin
              {
              { Go from 4 bits to 24 bit :)
              }
              Z:=0;
              For X:=0 To Width-1 Do
                  Begin
                  B1:=(Input[X Shr 1] Shr ((1-(X Mod 2))*4)) And $0F;
                  OutPut[Z+0]:=(PaletteVGA[B1,3]*255) Div 63;
                  OutPut[Z+1]:=(PaletteVGA[B1,2]*255) Div 63;
                  OutPut[Z+2]:=(PaletteVGA[B1,1]*255) Div 63;
                  Z:=Z+3;
                  End;
              End;
           End;
       End;
     8:Begin
       Case Ybits Of
            1:Begin
              For X:=0 To Width-1 Do
                  OutPut[X Shr 3]:=0;
              For X:=0 To Width-1 Do
                  Begin
                  B1:=InPut[X];
                  OutPut[X Shr 3]:=OutPut[X Shr 3] Or (B1 Shl (7-(X Mod 8)));
                  End;
              End;
            8:Begin
              Move(Input[0],Output[0],Width);
              End;
           24:Begin
              {
              { From 8 bit to 24 bit, hmmmmm 2EZ :)
              }
              Z:=0;
              For X:=0 To Width-1 Do
                  Begin
                  B1:=Input[X];
                  OutPut[Z+0]:=(PaletteVGA[B1,3]*255) Div 63;
                  OutPut[Z+1]:=(PaletteVGA[B1,2]*255) Div 63;
                  OutPut[Z+2]:=(PaletteVGA[B1,1]*255) Div 63;
                  Z:=Z+3;
                  End;
              End;
           End;
       End;
    24:Begin
       Case Ybits Of
            24:Begin
               Move(Input[0],Output[0],Width*3);
               End;
            End;
       End;
    End;
End;


Procedure SetUpMaskGrayPalette;
Var
  I,J:Word;
Begin
For J:=0 To 255 Do
    Begin
    For I:=1 To 3 Do
        Begin
        PaletteVga[J,I]:=J*63 Div 255;
        End;
    End;
End;

Function PCXGrayValue(R,G,B:Word):Word;
Begin
PCXGrayValue:=((R Shl 5)+(G Shl 6)+(B*12)) Div 108;
End;

Procedure MakePalBW(Const BitMap:TBitMap);
Begin
SysPal.LPal.palVersion:=$300;
SysPal.LPal.palNumEntries:=2;
Syspal.LPal.PalPalEntry[0].peRed:=0;
Syspal.LPal.PalPalEntry[0].peGreen:=0;
Syspal.LPal.PalPalEntry[0].peBlue:=0;
Syspal.LPal.PalPalEntry[0].peFlags:=0;
Syspal.Dummy[1].peRed:=255;
Syspal.Dummy[1].peGreen:=255;
Syspal.Dummy[1].peBlue:=255;
Syspal.Dummy[1].peFlags:=0;
Bitmap.Palette:= CreatePalette(Syspal.LPal);
End;

Procedure MakePalPalette(Const BitMap:TBitMap);
Var
  I:Word;
Begin
SysPal.LPal.palVersion:=$300;
SysPal.LPal.palNumEntries:=256;
For I:=0 To 255 Do
    Begin
    Syspal.LPal.PalPalEntry[I].peRed:=  (PaletteVga[I,1])*4;
    Syspal.LPal.PalPalEntry[I].peGreen:=(PaletteVga[I,2])*4;
    Syspal.LPal.PalPalEntry[I].peBlue:= (PaletteVga[I,3])*4;
    Syspal.LPal.PalPalEntry[I].peFlags:= 0;
    End;
Bitmap.Palette:= CreatePalette(Syspal.LPal);
End;

Procedure MakePalPaletteX(Const BitMap:TBitMap;HowMany:Word);
Var
  I:Word;
Begin
SysPal.LPal.palVersion:=$300;
SysPal.LPal.palNumEntries:=HowMany;
For I:=0 To HowMany-1 Do
    Begin
    Syspal.LPal.PalPalEntry[I].peRed:=  (PaletteVga[I,1])*4;
    Syspal.LPal.PalPalEntry[I].peGreen:=(PaletteVga[I,2])*4;
    Syspal.LPal.PalPalEntry[I].peBlue:= (PaletteVga[I,3])*4;
    Syspal.LPal.PalPalEntry[I].peFlags:= 0;
    End;
Bitmap.Palette:= CreatePalette(Syspal.LPal);
End;

Procedure SaveThePalette(Const HPal:HPalette;Var SavePal:TypePalette);
Var
  I:Word;
Begin
For I:=0 To 255 Do
    Begin
    Syspal.LPal.PalPalEntry[I].peRed:=0;
    Syspal.LPal.PalPalEntry[I].peGreen:=0;
    Syspal.LPal.PalPalEntry[I].peBlue:=0;
    End;
GetPaletteEntries(HPal,0,256,SysPal.LPal.PalPalEntry[0]);
For I:=0 To 255 Do
    Begin
    SavePal[I,1]:=(((Syspal.LPal.PalPalEntry[I].peRed)) Div 4);
    SavePal[I,2]:=(((Syspal.LPal.PalPalEntry[I].peGreen)) Div 4);
    SavePal[I,3]:=(((Syspal.LPal.PalPalEntry[I].peBlue)) Div 4);
    End;
End;

Procedure MakeGenPalette;
Var
  X:Word;
  R,G,B:Word;
Begin
X:=0;
For R:=0 To 7 Do
    Begin
    For G:=0 To 7 Do
        Begin
        For B:=0 To 3 Do
            Begin
            PaletteVga[X,1]:=(R+1)*8-1;
            PaletteVga[X,2]:=(G+1)*8-1;
            PaletteVga[X,3]:=(B+1)*16-1;
            Inc(X);
            End;
        End;
    End;
End;

Function  ShouldIKeepTrueFormat(Var BPP:Word):Boolean;
Begin
{
{ Choices
{    Use File Colors
{    Force 256 Colors
{    Force 16M Colors
}
If Global_KeepTrueFormat=0 Then
   ShouldIKeepTrueFormat:=True
Else
   ShouldIKeepTrueFormat:=False;
If Global_KeepTrueFormat=1 Then
   BPP:=8;
If Global_KeepTrueFormat=2 Then
   BPP:=24;
End;

Procedure DetColorVGA (Var PValue:Byte;MapValue:Byte);
Begin
PValue:=MapValue Div 4;
End;

Procedure PaletteDefaults;
Var
  J,I:Word;
Begin
For J:=0 To 15 Do
    Begin
    For I:=1 To 3 Do
        PaletteVGA[J,I]:=Global_PaletteDef[J,I];
    End;
End;

Procedure SetUpMaskAndColorMap;
Var
  R,G,B,PalBlue,PalGreen,PalRed:Byte;
  I:Integer;
  ColorMapSize:Integer;

Begin
{
{ Handle black and white images
}
ColorMapSize:=1 shl BitsPerPixel;
If BitsPerPixel=24 Then
   SetUpMaskGrayPalette
Else
    Begin
    For I:=0 to ColorMapSize-1 do
    Begin
              PalRed  :=FastGetbyte;
              PalGreen:=FastGetbyte;
              PalBlue :=FastGetbyte;
              If PcxVersion=2 Then
                 Begin
                 If PalRed<4 Then
                    PalRed:=PalRed*$55;
                 If PalGreen<4 Then
                    PalGreen:=PalGreen*$55;
                 If PalBlue<4 Then
                    PalBlue:=PalBlue*$55;
                 End;

    DetColorVGA (R,PalRed  );
    DetColorVGA (G,PalGreen);
    DetColorVGA (B,PalBlue );

    PaletteVGA[I,1]:=R;
    PaletteVGA[I,2]:=G;
    PaletteVGA[I,3]:=B;
    End;
    End;
End;

{
============================================
}

Procedure ReadPCXLine;
Var
   N,MaximumN,Z:Word;
   I:SmallInt;
   TmpB1,B1,C,CurrentPlane:Byte;
   CX:SmallInt;
   RealWidth:Integer;
Begin
N:=0;
Z:=0;
CurrentPlane:=0;
MaximumN:=PCXBytesPerLine*PcxColorPlanes;
RealWidth:=PcxBytesPerLine*8;
Repeat
    Begin
    B1:=FastGetByte;
    If B1 And $C0=$C0 Then
       Begin
       I:=B1 And $3F;
       C:=FastGetByte;
       While I>0 Do
             Begin
             Case BitsPerPixel Of
                  1:Begin
                    If (MyKeepTrueFormat=True) And (PcxColorPlanes=1) Then
                       Begin
                       TempArrayDBIG[Z]:=TempArrayDBIG[Z]+C;
                       Inc(Z);
                       End
                    Else
                       Begin
                       {
                       { 16 Color 4 planes or KEEP FORMAT=FALSE
                       }
                       For CX:=7 DownTo 0 Do
                          Begin
                          TmpB1:=0;
                          If C And (1 Shl CX) <>0 Then
                             TmpB1:=1;
                          TmpB1:=TmpB1 Shl CurrentPlane;
                          TempArrayDBIG[Z]:=TempArrayDBIG[Z]+TmpB1;
                          Inc(Z);
                          If Z>=RealWidth Then
                             Begin
                             Z:=0;
                             Inc(CurrentPlane);
                             End;
                          End;
                       End;
                    End;
                  8:Begin
                    TempArrayDBIG[Z]:=C;
                    Inc(Z);
                    End;
                End;
             Dec(I);
             Inc(N);
             End;
       End
    Else
       Begin
       Case BitsPerPixel Of
            1:Begin
              If (MyKeepTrueFormat=True) And (PcxColorPlanes=1) Then
                 Begin
                 TempArrayDBIG[Z]:=TempArrayDBIG[Z]+B1;
                 Inc(Z);
                 End
              Else
                 Begin
                 For CX:=7 DownTo 0 Do
                  Begin
                  TmpB1:=0;
                  If B1 And (1 Shl CX) <>0 Then
                     TmpB1:=1;
                  TmpB1:=TmpB1 Shl CurrentPlane;
                  TempArrayDBIG[Z]:=TempArrayDBIG[Z]+TmpB1;
                  Inc(Z);
                  If Z>=RealWidth Then
                     Begin
                     Z:=0;
                     Inc(CurrentPlane);
                     End;
                  End;
                 End;
              End;
            8:Begin
              TempArrayDBIG[Z]:=B1;
              Inc(Z);
              End;
            End;
       Inc(N);
       End;
    End;
Until N>=MaximumN;
End;

Procedure ReadPcxHeader(Var FileOk:Boolean;Var ErrorString:ShortString);
Label
  ExitIt;
Var
  B1:Byte;
  B2,X:Word;
  TopOfs,LeftOfs:Word;
Begin
B1:=FastGetByte;
If B1<>10 Then
   Begin
   ErrorString:='Not a PCX file, or header read error.';
   FileOk:=False;
   Goto ExitIt;
   End;
PcxVersion:=FastGetByte;
PcxEncoding:=FastGetByte;
BitsPerPixel:=FastGetByte;
LeftOfs:=FastGetWord;
TopOfs:=FastGetWord;
Width:=FastGetWord;
Height:=FastGetWord;
Width:=Width-LeftOfs+1;
Height:=Height-TopOfs+1;
FastGetWord;
FastGetWord;
B2:=BitsPerPixel;
BitsPerPixel:=4;
SetupMaskAndColorMap;
BitsPerPixel:=B2;
FastGetByte;
PcxColorPlanes:=FastGetByte;
PcxBytesPerLine:=FastGetWord;
PcxPaletteType:=FastGetWord;
For X:=1 To 58 Do
   FastGetByte;
If NOT(BitsPerPixel In [1,4,8,16,24,32]) Then
   Begin
   FileOk:=False;
   ErrorString:='Not a valid PCX file!';
   End;
ExitIt:;

End;

Procedure LoadFromFileX;
Var
  B1:Byte;
  I:SmallInt;
  NewWidth:Word;
  L1,L2:LongInt;
  PaletteOk:Boolean;
  FileOk:Boolean;
  Ptr1:Pointer;
Procedure UpDatePalette;
Var
  I:Integer;
begin
For I:=0 To 255 Do
    Syspal.LPal.PalPalEntry[I].peflags:=0;
   Case BitsPerPixel Of
        1:Begin
          If PcxColorPlanes=1 Then
             Begin
             If MyKeepTrueFormat Then
                BitMap.PixelFormat:=pf1bit
             Else
                Begin
                Case MyKeepTrueBits Of
                     8:BitMap.PixelFormat:=pf8bit;
                    24:BitMap.PixelFormat:=pf24bit;
                    End;
                End;
             MakePalBW(BitMap);
             End
          Else
             Begin
             BitMap.IgnorePalette:=False;
             SysPal.LPal.palVersion:=$300;
             SysPal.LPal.palNumEntries:=17;
             For I:=0 To 16 Do
                 Begin
                 Syspal.LPal.PalPalEntry[I].peRed:=  (PaletteVga[I,1]+1)*4-1;
                 Syspal.LPal.PalPalEntry[I].peGreen:=(PaletteVga[I,2]+1)*4-1;
                 Syspal.LPal.PalPalEntry[I].peBlue:= (PaletteVga[I,3]+1)*4-1;
                 End;
             If MyKeepTrueFormat Then
                BitMap.PixelFormat:=pf8bit
             Else
                Begin
                Case MyKeepTrueBits Of
                     8:BitMap.PixelFormat:=pf8bit;
                    24:BitMap.PixelFormat:=pf24bit;
                    End;
                End;
             Bitmap.Palette:= CreatePalette(Syspal.LPal);
             End;
          End;
        8:Begin
          If PcxColorPlanes=1 Then
             Begin
             If MyKeepTrueFormat Then
                BitMap.PixelFormat:=pf8bit
             Else
                Begin
                Case MyKeepTrueBits Of
                     8:BitMap.PixelFormat:=pf8bit;
                    24:BitMap.PixelFormat:=pf24bit;
                    End;
                End;
             MakePalPalette(BitMap);
             End
          Else
             Begin
             If MyKeepTrueFormat=True Then
                Begin
                BitMap.PixelFormat:=pf24bit;
                MakeGenPalette;
                End
             Else
                Begin
                Case MyKeepTrueBits Of
                     8:Begin
                       BitMap.PixelFormat:=pf8bit;
                       SetUpMaskGrayPalette
                       End;
                    24:Begin
                       BitMap.PixelFormat:=pf24bit;
                       MakeGenPalette;
                       End;
                    End;
                BitMap.IgnorePalette:=True;
                End;
             MakePalPalette(BitMap);
             End;
          End;
        End;
End;
Procedure Do8;
Var
  J:Word;
Begin
For J:=0 To Width-1 Do
    Begin
    TempArrayDBIG^[J]:=PCXGrayValue(
                       TempArrayDBIG^[J],
                       TempArrayDBIG^[PcxBytesPerLine+J],
                       TempArrayDBIG^[(PcxBytesPerLine Shl 1)+J]);
    End;
End;
Procedure Do24;
Var
  J,Z0,Z1,Z2,Z3:Word;
Begin
Z0:=0;
Z1:=0;
Z2:=PcxBytesPerLine;
Z3:=Z2+Z2;
For J:=0 To Width-1 Do
    Begin
    TempArrayDBIG16^[Z0+0]:=TempArrayDBIG^[Z3];
    TempArrayDBIG16^[Z0+1]:=TempArrayDBIG^[Z2];
    TempArrayDBIG16^[Z0+2]:=TempArrayDBIG^[Z1];
    Z0:=Z0+Global_HiColor;
    Inc(Z1);
    Inc(Z2);
    Inc(Z3);
    End;
Move(TempArrayDBIG16^,TempArrayDBIG^,NewWidth);
End;
Procedure Do8Adjust;
Begin
Move(TempArrayDBIG^,Ptr1^,Width);
End;
Procedure Do24Adjust;
Var
  X,Z:Word;
  B1:Byte;
Begin
Z:=0;
For X:=0 To Width-1 Do
    Begin
    B1:=TempArrayDBIG^[X];
    DataLineArray(Ptr1^)[Z+0]:=PaletteVGA[B1,3]*4+3;
    DataLineArray(Ptr1^)[Z+1]:=PaletteVGA[B1,2]*4+3;
    DataLineArray(Ptr1^)[Z+2]:=PaletteVGA[B1,1]*4+3;
    Z:=Z+Global_HiColor;
    End;
End;

Begin
MyKeepTrueFormat:=ShouldIKeepTrueFormat(MyKeepTrueBits);
ErrorString:='';
FileOk:=True;
OpenFile(FileName,FileOk);
ReadPcxHeader(FileOK,ErrorString);
If FileOk Then
   Begin
   BitMap.Height:=1;
   BitMap.Width:=1;
   BitMap.Height:=Height;
   BitMap.Width:=Width;
   UpdatePalette;
   {
   { Check version number for FAKE palette!
   }
   NewWidth:=Width*Global_HiColor;
   TempArrayDBIG:=Nil;
   TempArrayDBIG16:=Nil;
   GetMem(TempArrayDBig,Width*4+20{Slack Bytes});
   GetMem(TempArrayDBig16,NewWidth+20);
   PaletteOk:=True;
   If PcxVersion=3 Then
      Begin
      PaletteDefaults;
      End;
   If (BitsPerPixel=1) And (PcxColorPlanes=1) Then
      Begin
      PaletteVGA[0,1]:=0;
      PaletteVGA[0,2]:=0;
      PaletteVGA[0,3]:=0;
      PaletteVGA[1,1]:=63;
      PaletteVGA[1,2]:=63;
      PaletteVGA[1,3]:=63;
      End;
   If (BitsPerPixel=8) And (PcxColorPlanes=1) Then
      Begin
      {
      { Fast PALETTE Read On Picture (Could be wrong!)
      }
      L1:=FilePos(PictureFile);
      If SizeOf(IndexData)>L1 Then
         L1:=SizeOf(IndexData);
      L2:=L1-Index1;
      Seek(PictureFile,FileSize(PictureFile));
      L1:=FilePos(PictureFile);
      L1:=L1-(3*256+1);
      Seek(PictureFile,L1);
      FileIoReset;
   {
   { Reset GetByte Stuff!
   }
      B1:=FastGetByte;
      If B1<>$0C Then
         PaletteOk:=False;
      SetupMaskAndColorMap;
      Seek(PictureFile,L2);
      FileIoReset;
      End;
   If (BitsPerPixel=8) And (PcxColorPlanes=3) Then
      SetupMaskGrayPalette;
   I:=0;
   UpDatePalette;
   Repeat
    Begin
    If BitsPerPixel<>8 Then
       Begin
       FillerUp(TempArrayDBIG^[0],Width*PcxColorPlanes+20{Slack Bytes},0);
       End;
    ReadPCXLine;
    If (PCXColorPlanes=3) And
       (BitsPerPixel=8)   Then
       Begin
       {
       { 24 Bit Image!
       }
       If MyKeepTrueFormat Then
          Do24
       Else
          Begin
          Case MyKeepTrueBits Of
               8:Do8;
              24:Do24;
              End;
          End;
       End
    Else
       Begin
       {
       { 1,4 or 8 Bit file!
       }
       End;
    {
    { Put line into memory!
    }
    Ptr1:=BitMap.ScanLine[I];
    Case BitsPerPixel Of
         1:Begin
           If (MyKeepTrueFormat) And (PcxColorPlanes=1) Then
              Begin
              {
              { B&W Keep It
              }
              Move(TempArrayDBIG^,Ptr1^,PcxBytesPerLine*PcxColorPlanes)
              End
           Else
              Begin
              {
              { No KEEP or 16 Color
              }
              If MyKeepTrueFormat Then
                 Do8Adjust
              Else
                 Begin
                 Case MyKeepTrueBits Of
                      8:Do8Adjust;
                     24:Do24Adjust;
                     End;
                 End;
              End;
           End;
         8:Begin
           If PcxColorPlanes=1 Then
              Begin
              If MyKeepTrueFormat=True Then
                 Move(TempArrayDBIG^,Ptr1^,PcxBytesPerLine*PcxColorPlanes)
              Else
                 Begin
                 Case MyKeepTrueBits Of
                      8:Move(TempArrayDBIG^,Ptr1^,PcxBytesPerLine);
                     24:Do24Adjust;
                     End;
                 End;
              End
           Else
              Begin
              {
              { 24 bit file
              }
              If MyKeepTrueFormat Then
                 Move(TempArrayDBIG^,Ptr1^,PcxBytesPerLine*PcxColorPlanes)
              Else
                 Begin
                 Case MyKeepTrueBits Of
                      8:Move(TempArrayDBIG^,Ptr1^,Width);
                     24:Move(TempArrayDBIG^,Ptr1^,PcxBytesPerLine*PcxColorPlanes);
                     End;
                 End;
              End;
           End;
         End;
    Inc(I);
    End;
   Until I>=Height;
   {
   { Now read in REAL Palette!
   }
   If (BitsPerPixel=8) And (PcxColorPlanes=1) Then
      Begin
      If PaletteOk=False Then
         Begin
         FastGetByte;
         SetupMaskAndColorMap;
         End;
      End;
   If (BitsPerPixel=8) And (PcxColorPlanes=3) Then
      BitsPerPixel:=24;
   If (BitsPerPixel=1) And (PcxColorPlanes=4) Then
      BitsPerPixel:=4;
   FreeMem(TempArrayDBig16,NewWidth+20);
   FreeMem(TempArrayDBig,Width*4+20{Slack Bytes});
   If IoResult<>0 Then ;
   Close(PictureFile);
   End;
If IoResult<>0 Then ;
End;

Var
  TempArrayDBig2:^DataLineArray; {0-MaxWidth*4}
Var
  LocalPCXType:Word;
  CurrentColorPlane:Byte;
  MyWidth,MyHeight:Word;
  CurrBitsPerPixel:Word;
  InputBitsPerPixel:Word;
Procedure SaveToFileX(FileName:String;Const BitMap:TBitMap;PcxType:Byte);
Procedure WritePcxFile(FileName:String;MyPcxType:Byte);
Label
  ErrExitClose;
Var
  File1:File;
  B1:Byte;
  ResultStatus:Boolean;

Procedure DoBlockWriteF(Var B1:Byte);
Begin
BlockWrite(File1,B1,1);
End;

Procedure WriteHeader;
Var
  B1,B2:Byte;
  MyTopOfs,MyLeftOfs:Integer;
  X,Y:Word;
Begin
B1:=10;
DoBlockWriteF(B1);
B1:=5;
DoBlockWriteF(B1);
B1:=1;
DoBlockWriteF(B1);
Case MyPcxType Of
     1:B1:=1;
     2:B1:=1;
     3:B1:=8;
     4:B1:=8;
     End;
DoBlockWriteF(B1);
MyLeftOfs:=0;
MyTopOfs:=0;
B1:=Lo(MyLeftOfs);
DoBlockWriteF(B1);
B2:=Hi(MyLeftOfs);
DoBlockWriteF(B2);
B1:=Lo(MyTopOfs);
DoBlockWriteF(B1);
B2:=Hi(MyTopOfs);
DoBlockWriteF(B2);
B1:=Lo(MyLeftOfs+MyWidth-1);
DoBlockWriteF(B1);
B2:=Hi(MyLeftOfs+MyWidth-1);
DoBlockWriteF(B2);
B1:=Lo(MyTopOfs+MyHeight-1);
DoBlockWriteF(B1);
B2:=Hi(MyTopOfs+MyHeight-1);
DoBlockWriteF(B2);

B1:=Lo(MyWidth);
DoBlockWriteF(B1);
B2:=Hi(MyWidth);
DoBlockWriteF(B2);
B1:=Lo(MyHeight);
DoBlockWriteF(B1);
B2:=Hi(MyHeight);
DoBlockWriteF(B2);
{
{ Write Palette
}
For X:=0 To 15 Do
    Begin
    For Y:=1 To 3 Do
        Begin
        B1:=(PaletteVga[X,Y]*255) Div 63;
        DoBlockWriteF(B1);
        End;
    End;
B1:=0;
DoBlockWriteF(B1);
Case MyPcxType Of
     1:Begin
       PcxColorPlanes:=1;
       PcxBytesPerLine:=((MyWidth+7) Div 8);
       End;
     2:Begin
       PcxColorPlanes:=4;
       PcxBytesPerLine:=((MyWidth+7) Div 8);
       End;
     3:Begin
       PcxColorPlanes:=1;
       PcxBytesPerLine:=MyWidth;
       End;
     4:Begin
       PcxColorPlanes:=3;
       PcxBytesPerLine:=MyWidth;
       End;
     End;
B1:=PcxColorPlanes;
DoBlockWriteF(B1);
B1:=Lo(PcxBytesPerLine);
DoBlockWriteF(B1);
B1:=Hi(PcxBytesPerLine);
DoBlockWriteF(B1);
B1:=1;
DoBlockWriteF(B1);
B1:=0;
DoBlockWriteF(B1);
For X:=1 To 58 Do
    DoBlockWriteF(B1);
End;

(*
Procedure WritePcxLine(Var MyTempArray;Var Z:Word);
Var
  CurrentColorPlane,NumBytes,MaxX,W,X,Y:Integer;
  Ch,Dup:Byte;
Function MyGetByte(X:Word):Byte;
Var
  NewCh:Byte;
  Y:Integer;
Begin
Case MyPcxType Of
     1:Begin
       NewCh:=0;
       For Y:=7 DownTo 0 Do
           Begin
           NewCh:=NewCh Or ((DataLineArray(MyTempArray)[X] And 1) Shl Y);
           Inc(X);
           End;
       End;
     2:Begin
       {
       { Take 1st bit from next 8 bytes
       }
       NewCh:=0;
       For Y:=7-CurrentColorPlane DownTo 0-CurrentColorPlane Do
           Begin
           If Y<0 Then
              NewCh:=NewCh Or ((DataLineArray(MyTempArray)[X] And (1 Shl CurrentColorPlane)) Shr Abs(Y))
           Else
              NewCh:=NewCh Or ((DataLineArray(MyTempArray)[X] And (1 Shl CurrentColorPlane)) Shl Y);
           Inc(X);
           End;
       End;
     3:Begin
       NewCh:=DataLineArray(MyTempArray)[X];
       End;
     End;
MyGetByte:=NewCh;
End;

Begin
Case MyPcxType Of
     1:Begin
       W:=8;
       End;
     2:Begin
       W:=8;
       End;
     3:Begin
       W:=1;
       End;
     End;
MaxX:=PcxBytesPerLine*W;
Z:=0;
X:=0;
NumBytes:=0;
CurrentColorPlane:=0;
Repeat
    Begin
    {
    { Get whole BYTE!
    }
    {
    { Get runs!
    { Repeat
    { Until X=Width or DUP>63
    {
    }
    Dup:=1;
    While
          (X<Width-1)                   And
          (MyGetByte(X)=MyGetByte(X+W)) And
          (Dup<63)                      And
          (Dup+NumBytes<PcxBytesPerLine) Do
          Begin
          Inc(Dup);
          X:=X+W;
          End;
    Ch:=MyGetByte(X);
    If (Dup>1) Or (Ch>=$C0) Then
       Begin
       TempArrayDBIG[Z]:=$C0+Dup;
       Inc(Z);
       TempArrayDBIG[Z]:=Ch;
       Inc(Z);
       End
    Else
       Begin
       TempArrayDBIG[Z]:=Ch;
       Inc(Z);
       End;
    X:=X+W;
    NumBytes:=NumBytes+Dup;
    If X>=MaxX Then
       Begin
       Inc(CurrentColorPlane);
       X:=0;
       NumBytes:=0;
       End;
    End;
Until CurrentColorPlane>=PcxColorPlanes;
End;
*)

Procedure WritePcxLine(Var MyTempArray;Var ZZ:Word);
Label
  DOWP1,DOWP2,DOWP3,DOWPX,WPRLOOP1,WPWLOOP1,WPCONT1,
  DODUP,DOWPONE,DODUPEND,LJA,WPEX;
Var
  DUP,W,X,NumBytes,MaxX:Word;
  OldAX,FastAX:Word;
Function MyGetByte(X:Word):Byte;
Label
  DOMG1,DOMG2,DOMG3,DOMGX,LOOP1A,LOOP2A,L3B,L3X,IS8;
Var
  MyAX:Word;
Begin
        ASM
        PUSH    ESI
        MOV     EBX,0
        MOV     BX,AX
        CMP     LOCALPCXTYPE,1
        JZ      DOMG1
        CMP     LOCALPCXTYPE,2
        JZ      DOMG2
        CMP     LOCALPCXTYPE,3
        JZ      DOMG3
        CMP     LOCALPCXTYPE,4
        JZ      DOMG3
        JMP     DOMGX
DOMG1:
{
{ If we already are in 2 color mode, then just get the byte
}
        CMP     CURRBITSPERPIXEL,1
        JNZ     IS8
        SHR     EBX,3
        MOV     AL,[EDI+EBX]
        JMP     DOMGX
IS8:
        MOV     DX,8
        MOV     AL,0
LOOP1A:
        MOV     AH,[EDI+EBX]
        AND     AH,1
        MOV     CL,DL
        DEC     CL
        SHL     AH,CL
        OR      AL,AH
        INC     BX
        DEC     DX
        JNZ     LOOP1A
        JMP     DOMGX
DOMG2:
        MOV     DH,CURRENTCOLORPLANE
        MOV     DL,7
        SUB     DL,DH
        MOV     AL,0
LOOP2A:
        CMP     DL,0
        JGE     L3B
        MOV     AH,[EDI+EBX]
        MOV     CH,1
        MOV     CL,DH
        SHL     CH,CL
        AND     AH,CH

        MOV     CL,DL
        NEG     CL
        SHR     AH,CL
        OR      AL,AH
        JMP     L3X
L3B:
        MOV     AH,[EDI+EBX]
        MOV     CH,1
        MOV     CL,DH
        SHL     CH,CL
        AND     AH,CH

        MOV     CL,DL
        SHL     AH,CL
        OR      AL,AH
L3X:
        INC     BX
        DEC     DL
        MOV     CL,0
        SUB     CL,DH
        CMP     DL,CL                           {;AT BOTTOM YET?}
        JGE     LOOP2A
        JMP     DOMGX
DOMG3:
        MOV     AL,[EDI+EBX]
DOMGX:
        MOV     AH,0
        MOV     MYAX,AX
        POP     ESI
        END;
MyGetByte:=MyAX;
End;


Begin
LocalPCXType:=MyPcxType;
        ASM
        PUSHA
        PUSH    ESI
        PUSH    EDI
        MOV     EDI,MYTEMPARRAY;
        MOV     ESI,TEMPARRAYDBIG
        CMP     LOCALPCXTYPE,1
        JZ      DOWP1
        CMP     LOCALPCXTYPE,2
        JZ      DOWP2
        CMP     LOCALPCXTYPE,3
        JZ      DOWP3
        CMP     LOCALPCXTYPE,4
        JZ      DOWP3
        JMP     DOWPX
DOWP1:  MOV     W,8
        JMP     DOWPX
DOWP2:  MOV     W,8
        JMP     DOWPX
DOWP3:  MOV     W,1
DOWPX:
        MOV     AX,PCXBYTESPERLINE
        MOV     BX,W
        MUL     BX
        MOV     MAXX,AX
        MOV     EAX,ZZ
        MOV     WORD PTR [EAX],0
        MOV     X,0
        MOV     NUMBYTES,0
        MOV     CURRENTCOLORPLANE,0
WPRLOOP1:
        MOV     DUP,1
        MOV     AX,X
        PUSH    EBP
        CALL    MYGETBYTE
        POP     ECX
        MOV     FASTAX,AX
WPWLOOP1:
        MOV     AX,FASTAX
        MOV     OLDAX,AX
        PUSH    AX
        MOV     AX,X
        ADD     AX,W
        PUSH    EBP
        CALL    MYGETBYTE
        POP     ECX
        POP     BX
        MOV     FASTAX,BX
        CMP     AX,BX
        JNZ     WPCONT1
        MOV     AX,X
        INC     AX
        CMP     AX,MYWIDTH
        JGE     WPCONT1
        CMP     DUP,63
        JGE     WPCONT1
        MOV     AX,DUP
        ADD     AX,NUMBYTES
        CMP     AX,PCXBYTESPERLINE
        JGE     WPCONT1
        INC     DUP
        MOV     AX,W
        ADD     X,AX
        JMP     WPWLOOP1
WPCONT1:
        MOV     AX,OLDAX
        CMP     DUP,1
        JG      DODUP
        CMP     AL,0C0H
        JGE     DODUP
        JMP     DOWPONE
DODUP:
        MOV     ECX,ZZ
        MOVZX   EBX,WORD PTR [ECX]
        MOV     AH,0C0H
        OR      AH,BYTE PTR DUP
        MOV     [ESI+EBX],AH                   {;TEMPARRAYDBIG}
        MOV     ECX,ZZ
        INC     WORD PTR [ECX]
        MOV     [ESI+EBX+1],AL                 {;TEMPARRAYDBIG}
        MOV     ECX,ZZ
        INC     WORD PTR [ECX]
        JMP     DODUPEND
DOWPONE:
        MOV     ECX,ZZ
        MOVZX   EBX,WORD PTR [ECX]
        MOV     [ESI+EBX],AL                   {;TEMPARRAYDBIG}
        MOV     ECX,ZZ
        INC     WORD PTR [ECX]
DODUPEND:
        MOV     AX,W
        ADD     X,AX
        MOV     AX,DUP
        ADD     NUMBYTES,AX
        MOV     AX,X
        CMP     AX,MAXX
        JL      LJA
        INC     CURRENTCOLORPLANE
        MOV     X,0
        MOV     NUMBYTES,0
LJA:
        MOV     AL,CURRENTCOLORPLANE
        CMP     AL,PCXCOLORPLANES
        JGE     WPEX
        JMP     WPRLOOP1
WPEX:
        POP     EDI
        POP     ESI
        POPA
        END;
End;

Procedure PixelConvertRGBLines(Var TempArrayD,TempArrayDBIG2:DataLineArray);
Label
   PCRL_1,PCRL_24,PCRL_EXIT;
Begin
        ASM
        PUSHA
        PUSH    ESI
        PUSH    EDI
        MOVZX   ECX,MYWIDTH
        MOV     EDI,TEMPARRAYDBIG2
        MOV     ESI,TEMPARRAYD
        CMP     CURRBITSPERPIXEL,8
        JZ      PCRL_1
        CMP     CURRBITSPERPIXEL,24
        JZ      PCRL_24
PCRL_1:
        MOV     AH,0
        MOV     AL,[ESI]
{
{ GET PALETTE COLORS
}
        MOV     EBX,0
        MOVZX   EBX,AX
        SHL     EBX,1
        ADD     BX,AX
        MOV     AL,BYTE PTR PALETTEVGA[EBX+0]
        MOV     DL,BYTE PTR PALETTEVGA[EBX+1]
        MOV     DH,BYTE PTR PALETTEVGA[EBX+2]
        MOVZX   EBX,MYWIDTH
        SHL     AL,2
        SHL     DL,2
        SHL     DH,2
        MOV     [EDI],AL
        MOV     [EDI+EBX],DL
        SHL     EBX,1
        MOV     [EDI+EBX],DH
        INC     ESI
        INC     EDI
        LOOP    PCRL_1
        JMP     PCRL_EXIT
PCRL_24:
        MOV     AL,[ESI+2]
        MOV     DL,[ESI+1]
        MOV     DH,[ESI+0]
        MOVZX   EBX,MYWIDTH
        MOV     [EDI],AL
        MOV     [EDI+EBX],DL
        SHL     EBX,1
        MOV     [EDI+EBX],DH
        ADD     ESI,3
        INC     EDI
        LOOP    PCRL_24
        JMP     PCRL_EXIT
PCRL_EXIT:
        POP     EDI
        POP     ESI
        POPA
        END;
End;

Procedure WriteBody(Var ResultStatus:Boolean);
Var
  Z:Word;
  TmpPCXColorPlanes:Word;
  I:Integer;
Begin
TmpPCXColorPlanes:=PCXColorPlanes;
I:=0;
ResultStatus:=True;
Repeat
    Begin
    TempArrayD:=BitMap.ScanLine[I];
    {
    { Convert Any From
    }
    Case InPutBitsPerPixel Of
         1,4,8:Begin
               ConvertXBitsToYBits(TempArrayD^,TempArrayD2^,InputBitsPerPixel,8,MyWidth);
               CurrBitsPerPixel:=8;
               End;
            24:Begin
               ConvertXBitsToYBits(TempArrayD^,TempArrayD2^,InputBitsPerPixel,24,MyWidth);
               End;
         End;
    Case MyPcxType Of
         1..3:Begin
              WritePCXLine(TempArrayD2^,Z);
              BlockWrite(File1,TempArrayDBIG^[0],Z);
              End;
            4:Begin
              PCXColorPlanes:=1;
              {
              { Special Triple Plane Thingy :)
              }
              PixelConvertRGBLines(TempArrayD2^,TempArrayDBIG2^);
              WritePCXLine(TempArrayDBIG2^[0],Z);
              BlockWrite(File1,TempArrayDBIG^[0],Z);
              WritePCXLine(TempArrayDBIG2^[MyWidth],Z);
              BlockWrite(File1,TempArrayDBIG^[0],Z);
              WritePCXLine(TempArrayDBIG2^[MyWidth*2],Z);
              BlockWrite(File1,TempArrayDBIG^[0],Z);
              End;
            End;
    If IoResult<>0 Then
       ResultStatus:=False;
    Inc(I);
    End;
Until (I>=MyHeight) Or (ResultStatus=False);
PCXColorPlanes:=TmpPCXColorPlanes;
End;

Procedure Write256Palette;
Var
  X,Y:Word;
  B1:Byte;
Begin
For X:=0 To 255 Do
    Begin
    For Y:=1 To 3 Do
        Begin
        B1:=(PaletteVga[X,Y]*255) Div 63;
        DoBlockWriteF(B1);
        End;
    End;
End;

Begin
{
{ Write PCX File Write out either 2,16,256 colors
{
}
SaveThePalette(BitMap.Palette,PaletteVGA);
MyWidth:=BitMap.Width;
MyHeight:=BitMap.Height;
Case BitMap.PixelFormat Of
     pf1bit:CurrBitsPerPixel:=1;
     pf4bit:CurrBitsPerPixel:=4;
     pf8bit:CurrBitsPerPixel:=8;
     pf24bit:CurrBitsPerPixel:=24;
     End;
InputBitsPerPixel:=CurrBitsPerPixel;
TempArrayDBIG:=Nil;
TempArrayDBIG2:=Nil;
GetMem(TempArrayDBig,MyWidth*4);
GetMem(TempArrayDBig2,MyWidth*4);
GetMem(TempArrayD2,MyWidth*4);
Assign(File1,FileName);
ReWrite(File1,1);
WriteHeader;
WriteBody(ResultStatus);
If ResultStatus=False Then
   Begin
   {
   { Put ERROR handler here if you like!
   { ###ERROR###
   }
   Goto ErrExitClose;
   End;
B1:=$0C;
DoBlockWriteF(B1);
Write256Palette;
ErrExitClose:;
Close(File1);
FreeMem(TempArrayD2,Width*4);
FreeMem(TempArrayDBig2,Width*4);
FreeMem(TempArrayDBig,Width*4);
End;

Begin
WritePcxFile(FileName,PcxType);
End;

End.

来自于http://www.efg2.com/Lab/Library/Delphi/Graphics/FileFormatsAndConversion.htm的源码（点此下载）。

Dserver
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Delphi下有关图样处理的软件,完美支持JPG,PCX等格式.
06-14
Delphi下有关图样处理的软件,完美支持JPG,PCX等格式.
PCX Image是一款针对Borland Delphi and C++ Builder开发者提供的使用工具
weixin_33805557的博客
04-14 91
PCX Image是一款针对Borland Delphi and C++ Builder开发者提供的使用工具，可支持预览，操作，打印PCX 格式。具体功能：PCX Image控件的主类TsgPCXImage继承自TGraphic，而且重载了其中的方法。您可以在其它的图形显示控件中，使用PCX Image控件来显示和浏览PCX图片，如：ABViewer控CAD控件件。CAD控件...
PCX 图象文件格式的读写
cadinfo的专栏
06-07 5203
PCX 图象文件格式的读写PCX图象文件格式最早出现于Zsoft公司开发的PC Paintbrush绘图软件，由于该绘图软件功能强大并成功移植到Windows操作系统，加上PCX是最早支持彩色的图象格式之一，PCX成为目前比较流行的图象格式。对于开发图象浏览、处理软件的程序员来讲，如何读取、保存PCX图象格式是最为基本的话题，作者根据自己对PCX图象格式理解，开发了相应的代码，希望对读者有
C# 转换图形为PCX 格式
Zgke
05-20 5610
2010-5-27PCX RLE压缩图形的行对齐比.NET多了一位.已经修正了. 2009 -7-25C# 转换图形为PCX 格式 增加了对1位色的PCX的读取 2009-6 -12 RLE数据压缩更改 颜色RGB在RLE压缩不换行处理.....  .NET 支持的格式..保存成PCX格式..目前只支持两种结果 256色图  和24位图... 其他位的以
Delphi image 程式庫,可以載入及儲存JPEG, PNG/APNG, GIF, TGA, DDS, MNG, JNG, JPEG2000, PSD, TIFF, PGM, PPM, PAM, PFM, XPM, (loading only) PCX, and PBM等格式
04-09
Imaging is native Object Pascal image loading, saving and manipulation library. It is available for several platforms and does not require any third party dynamic libraries or other compiled binaries. , It is available for JPEG, PNG/APNG, GIF, TGA, DDS, MNG, JNG, JPEG2000, PSD, TIFF, PGM, PPM, PAM, PFM, XPM, (loading only) PCX, and PBM
Vb将其它图像格式转换为BMP文件
05-16
内容索引:VB源码,图形处理,图像转换　Vb利用内部机制实现图像格式转换，将JPG/GIF/BMP/pcx/ico等多种图像格式最终转换为BMP文件，转换过程主要表现在文件保存上，将其它格式文件直接保存了BMP，相当于转换格式。
专业的CAD图形文件转换和查看软件（免安装）
03-19
·可将 CAD 文件输出为 BMP/JPG/GIF/PCX/Tiff/WMF 点阵图。 ·可将 CAD 文件输出为 PDF 文件，支持 PDF 文件加密。 ·可将 CAD 文件输出为 SVG/HP-GL-2/EPS/CGM 矢量图。 ·支持 DWG 和 DXF 文件互转。 ·支持 ...
2345图片格式转换王 2.8 正式版.zip
07-10
2345图片格式转换王 V2.8提供多种图片的压缩裁剪转换功能。目前支持图片转换的格式有：BMP JPG GIF PNG CUR TIF TGA PCX WBMP WMF JP2 JPC PGX RAW SKA。支持导出的图片格式有：BMP JPG GIF PNG TIFF TGA PCX PNM 。
万能图像格式批量转换工具1.3
12-05
本工具支持：DDS图片,BMP图片,GIF图片,JPG图片,PNG图片,ICO图片,TIF图片,TGA图片,PCX图片...1.2版 支持了 DDS文件转换为PNG或JPEG格式，同时支持任意格式转换为DDS格式图片文件！ 1.1版 支持了 以上格式转换为 ICO文件
易语言-易语言图片格式转换器
06-25
源码用到多线程支持库，图像格式转换支持库。
图像处理(PCX图档)
12-26
程式分为两部分，图片部分：对PCX文档的解码，包含灰阶，二值化，直方图均衡化、规定化、对比拉伸，碎形压缩，多种滤波器实现，旋转，缩放，位图，浮水印...等功能(这些功能是不局限于PCX档，可以移植)。影像部分：主要实现了影像的压缩，两帧(即两幅图)间基于Block 的压缩。功能的详解在我的blog可以看到。
支持多种格式的图片显示Demo（PCX）
01-19
image显示处理，显示20多种格式的图片
tsc打印机DLL库函数说明文档
09-06
该文档可用于TSC打印机的二次开发编程，介绍了dll库中的函数调用方法与参数。
C#解析PCX图形文件..
Zgke
05-19 4877
2009-05-20  新添了两个方法  一个保存  另外支持8位色的PCX 连接　　http://blog.csdn.net/zgke/archive/2009/05/20/4204090.aspx 图片来源  ACDESS 3.1 转换出来的PCX文件.. 其实分析了下....PCX的24位图还真有意思....先相素红--绿--蓝 ..每个元素都是RLE压缩 到.NET下还
C# 处理PGM、Pcx、Pnm、Ras、Sgi、Tga、Xpm 等图片，读取与显示
静哥亻门
07-18 1135
如题，最近的项目遇到需要处理小众图片格式，于是在度娘的帮助下，两天未果。 此刻用激动的心情发一张显示的PGM图片的效果。 有了满意的效果，才能继续下去。在国内没有找到，之后就去cn.bing.com。根据搜索出来的结果，有了新的启发，就是使用NugGet包处理问题。如下图： 于是锁定了前两个。但是问题来了，安装了包，却没有对应的文档可用。还得下载了源码看！ 调用实例： pub...
C++图像处理 -- PCX格式图像（下）
闲人阿发伯的业余编程心得
01-28 5023
阅读提示：    《C++图像处理》系列以代码清晰，可读性为主，全部使用C++代码。    《Delphi图像处理》系列以效率为侧重点，一般代码为PASCAL，核心代码采用BASM。    尽可能保持二者内容一致，可相互对照。     《C++图像处理 -- PCX格式图像（上）》将PCX格式图像转换为GDI+位图，本文则介绍将GDI+位图转换为PCX格式图像。    下面是GDI+位图转换为PC
C# 转换图形为PCX 格式 增加了对1位色的PCX的读取
dz45693的专栏
10-29 3590
C# 转换图形为PCX 格式 增加了对1位色的PCX的读取
C# 生成各种格式各种大小的图片类
php|nginx|python|vue|redis|linux
05-21 1120
using System;using System.Collections.Generic;using System.Text;using System.Drawing;using System.Drawing.Drawing2D;using System.Drawing.Imaging;namespace Chen{    public class Thumbnail    {       
java 图片转成pcx,使用c#将png文件转换为pcx文件
weixin_39637397的博客
03-11 489
我正在尝试将.png文件转换为.pcx文件.方案如下：我正在使用TSC TTP-343C标签打印机.在标签上我必须打印图像. TSC为开发人员提供了library documentation.由于我只能使用pcx文件在这些标签上打印图像,我必须将所有图像转换为pcx图像.任何其他格式或甚至不正确的pcx格式(例如,如果用户刚刚重命名文件结尾)将不会打印在标签上.我见过this post链接到Mag...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值