//------------------------------------------------------------------------------
protected void ReadHeader(BinaryReader r)
{
// signature
Images.Version = new string(r.ReadChars(6));
if (Images.Version != "GIF87a" && Images.Version != "GIF89a")
{
throw new Exception("Unsupported GIF version");
}
// read header
Images.Width = r.ReadUInt16();
Images.Height = r.ReadUInt16();
ImageFlags = (ImageFlag)r.ReadByte();
var bgIndex = r.ReadByte();
r.ReadByte(); // aspect ratio
Images.BitDepth = (int)(ImageFlags & ImageFlag.BitDepthMask) >> 4 + 1;
if ((ImageFlags & ImageFlag.ColourTable) == ImageFlag.ColourTable)
{
GlobalColourTable = ReadColourTable(ImageFlags, r);
if (bgIndex < GlobalColourTable.Length)
{
BackgroundColour = GlobalColourTable[bgIndex];
}
}
}
public VerifyResult()
{
Key = "";
ErrorCode = 0;
AnnexData = "";
Flags = new ImageFlag();
}
/// <summary>
/// 在图片上绘制标记
/// </summary>
/// <param name="flag"></param>
private void DrawFlag(ImageFlag flag)
{
this.Invoke(new MethodInvoker(delegate()
{
Image img = null;
if (pic1.Image != null)
{
img = pic1.Image.Clone() as Image;
}
if (img != null)
{
Pen pen = new Pen(Color.Blue, 2.0f);
Graphics g = Graphics.FromImage(img);
for (int i = 0; i < flag.targets.Count; i++)
{
Flag flagInfo = flag.targets[i];
//绘制检测类型
g.DrawString(flagInfo.label + "[" + flagInfo.conf + "]", new Font("宋体", 14f, FontStyle.Bold), Brushes.Red, flagInfo.x, flagInfo.y - 20);
//绘制目标框
g.DrawRectangle(pen, flagInfo.x, flagInfo.y, flagInfo.w, flagInfo.h);
}
pic2.Image = img;
}
}));
}
private VerifyResult PostImage2(string guid)
{
if (string.IsNullOrWhiteSpace(guid))
{
guid = Guid.NewGuid().ToString();
}
try
{
VerifyResult result = verProcess.VerifyImage(urlTmp, guid, imgData2);
ImageFlag flag = null;
if (result != null)
{
flag = result.Flags;
}
if (flag != null && flag.targets != null)
{
DrawFlag(flag);
}
return(result);
}
catch (Exception exp)
{
Logger.AddLog(this.GetType(), "PostImage2", "", exp);
return(null);
}
finally
{
}
}
//------------------------------------------------------------------------------
Color32[] ReadColourTable(Color32[] colourTable, ImageFlag flags)
{
var tableSize = Pow2[(int)(flags & ImageFlag.TableSizeMask) + 1];
for (var i = 0; i < tableSize; i++)
{
colourTable[i] = new Color32(
Input[D++],
Input[D++],
Input[D++],
0xFF
);
}
return(colourTable);
}
//------------------------------------------------------------------------------
private Color32[] ReadColourTable(ImageFlag flags, BinaryReader r)
{
var tableSize = (int)Math.Pow(2, (int)(flags & ImageFlag.TableSizeMask) + 1);
var colourTable = new Color32[tableSize];
for (var i = 0; i < tableSize; i++)
{
colourTable[i] = new Color32(
r.ReadByte(),
r.ReadByte(),
r.ReadByte(),
0xFF
);
}
return(colourTable);
}
private void PostImage()
{
try
{
string filePath = "";
string url = "";
this.Invoke(new MethodInvoker(delegate()
{
filePath = txtPicPath.Text;
url = txtUrl.Text;
btnExecute.Enabled = false;
}));
if (!File.Exists(filePath))
{
return;
}
var fileName = filePath.Substring(filePath.LastIndexOf("\\") + 1);
byte[] imgData = File.ReadAllBytes(filePath);
VerifyResult result = verProcess.VerifyImage(txtUrl.Text, fileName, imgData);
ImageFlag flag = null;
if (result != null)
{
flag = result.Flags;
}
if (flag != null && flag.targets != null)
{
DrawFlag(flag);
}
}
catch (Exception exp)
{
Logger.AddLog(this.GetType(), "PostImage", "", exp);
}
finally
{
this.Invoke(new MethodInvoker(delegate()
{
btnExecute.Enabled = true;
}));
}
}
//------------------------------------------------------------------------------
protected void ReadImageBlock(BinaryReader r)
{
// read image block header
ImageLeft = r.ReadUInt16();
ImageTop = r.ReadUInt16();
ImageWidth = r.ReadUInt16();
ImageHeight = r.ReadUInt16();
ImageFlags = (ImageFlag)r.ReadByte();
ImageInterlaced = (ImageFlags & ImageFlag.Interlaced) == ImageFlag.Interlaced;
if (ImageWidth == 0 || ImageHeight == 0)
{
return;
}
if ((ImageFlags & ImageFlag.ColourTable) == ImageFlag.ColourTable)
{
ActiveColourTable = ReadColourTable(ImageFlags, r);
}
else
{
ActiveColourTable = GlobalColourTable;
}
LzwMinimumCodeSize = r.ReadByte();
// compressed image data
var lzwData = ReadImageBlocks(r);
// this disposal method determines whether we start with a previous image
OutputBuffer = null;
switch (ControlDispose)
{
case Disposal.None:
case Disposal.DoNotDispose:
{
var prev = Images.Images.Count > 0 ? Images.Images[Images.Images.Count - 1] : null;
if (prev != null && prev.RawImage != null)
{
OutputBuffer = prev.RawImage.Clone() as Color32[];
}
}
break;
case Disposal.ReturnToPrevious:
for (int i = Images.Images.Count - 1; i >= 0; i--)
{
var prev = Images.Images[i];
if (prev.DisposalMethod == Disposal.None || prev.DisposalMethod == Disposal.DoNotDispose)
{
OutputBuffer = prev.RawImage.Clone() as Color32[];
break;
}
}
break;
case Disposal.RestoreBackground:
default:
break;
}
if (OutputBuffer == null)
{
var size = Images.Width * Images.Height;
OutputBuffer = new Color32[size];
for (int i = 0; i < size; i++)
{
OutputBuffer[i] = ClearColour;
}
}
// create image
var img = new Image(Images);
img.Delay = ControlDelay * 10; // (gif are in 1/100th second) convert to ms
img.DisposalMethod = ControlDispose;
//var sw = new Stopwatch(); sw.Start();
img.RawImage = DecompressLZW(lzwData);
//sw.Stop(); UnityEngine.Debug.Log( $"{sw.ElapsedTicks} ticks, {sw.ElapsedMilliseconds}ms" );
if (ImageInterlaced)
{
img.RawImage = Deinterlace(img.RawImage, ImageWidth);
}
Images.Add(img);
}
public static unsafe extern void vlImageSetFlag(ImageFlag imageFlag, [MarshalAs(UnmanagedType.U1)]bool bState);
public static unsafe extern bool vlImageGetFlag(ImageFlag imageFlag);
public static unsafe extern void vlImageSetFlag(ImageFlag ImageFlag, bool bState);
public unsafe static extern bool vlImageGetFlag(ImageFlag ImageFlag);
public unsafe static void vlImageSetFlag(ImageFlag ImageFlag, bool bState)
{
if (IsWow64()) x64.vlImageSetFlag(ImageFlag, bState); else x86.vlImageSetFlag(ImageFlag, bState);
}
public unsafe static bool vlImageGetFlag(ImageFlag ImageFlag)
{
return IsWow64() ? x64.vlImageGetFlag(ImageFlag) : x86.vlImageGetFlag(ImageFlag);
}
