private void toolStripButtonVideoRec_Click(object sender, EventArgs e)
{
uEye.Defines.Status statusRet = uEye.Defines.Status.SUCCESS;
if (toolStripButtonVideoRec.Checked)
{
SaveFileDialog fileDialog = new SaveFileDialog();
fileDialog.Filter = "Video file (*.avi)|*.avi";
fileDialog.DefaultExt = "avi";
if (fileDialog.ShowDialog() == DialogResult.OK)
{
statusRet = m_Camera.Video.Start(fileDialog.FileName);
if (statusRet != uEye.Defines.Status.SUCCESS)
{
MessageBox.Show("Could not start video recording");
toolStripButtonVideoRec.Checked = false;
}
}
else
{
toolStripButtonVideoRec.Checked = false;
}
}
else
{
statusRet = m_Camera.Video.Stop();
}
}
/// <summary>
/// 初始化相机
/// </summary>
/// <returns></returns>
public override bool Init()
{
camera = new uEye.Camera();
// Open Camera
statusRet = camera.Init();
if (statusRet != uEye.Defines.Status.Success)
{
SetError("Camera initializing failed");
return(false);
}
// Allocate Memory
statusRet = camera.Memory.Allocate();
if (statusRet != uEye.Defines.Status.Success)
{
SetError("Allocate Memory failed");
return(false);
}
// start capture
if (uEye.Defines.Status.Success == camera.Acquisition.Capture())
{
return(true);
}
else
{
SetError("Capture live show from camera failed!");
return(false);
}
}
public void LoadParameters(string parameters_file)
{
uEye.Defines.Status statusRet = 0;
Int32[] memList;
statusRet = Camera.Memory.GetList(out memList);
if (statusRet != uEye.Defines.Status.Success)
{
throw new Exception("Get memory list failed: " + statusRet);
}
statusRet = Camera.Memory.Free(memList);
if (statusRet != uEye.Defines.Status.Success)
{
throw new Exception("Free memory list failed: " + statusRet);
}
statusRet = Camera.Parameter.Load(parameters_file);
if (statusRet != uEye.Defines.Status.Success)
{
throw new Exception("Loading parameter failed: " + statusRet);
}
uEye.Types.Size <int> t = new uEye.Types.Size <int>();
statusRet = Camera.Memory.Allocate();
if (statusRet != uEye.Defines.Status.SUCCESS)
{
throw new Exception("Allocate Memory failed");
}
}
public void OnExit()
{
//close display window
if (display)
{
imVis.Unload();
vis.Dispose();
}
m_IsLive = false;
uEye.Defines.Status statusRet = uEye.Defines.Status.SUCCESS;
//Termminate video recording (if initiated)
if (m_Camera.Video.Running)
{
statusRet = m_Camera.Video.Stop();
}
//Termnate frame acquisition
statusRet = m_Camera.Acquisition.Stop();
if (m_Camera.IsOpened)
{
m_Camera.Exit();
}
this.Abort();
this.Dispose();
}
private void Button_Load_Parameter_Click(object sender, EventArgs e)
{
uEye.Defines.Status statusRet = 0;
m_Camera.Acquisition.Stop();
ClearSequence();
FreeImageMems();
statusRet = m_Camera.Parameter.Load("");
if (statusRet != uEye.Defines.Status.Success)
{
MessageBox.Show("Loading parameter failed: " + statusRet);
}
// Allocate Memory
statusRet = AllocImageMems();
if (statusRet != uEye.Defines.Status.Success)
{
MessageBox.Show("Allocate Memory failed");
Environment.Exit(-1);
}
statusRet = InitSequence();
if (statusRet != uEye.Defines.Status.Success)
{
MessageBox.Show("Add to sequence failed");
Environment.Exit(-1);
}
if (m_bLive == true)
{
m_Camera.Acquisition.Capture();
}
}
// FUNCTION: DownloadImage: Pull image down from camera
//
// In this routine we create two bitmaps:
// bitmap_Current (full size)
// bitmap_CurrentRed (reduced for display)
private void DownloadImage()
{
uEye.Defines.Status statusRet = 0;
// Get last image memory
Int32 s32LastMemId, s32Width, s32Height;
// figure out how big the image is
statusRet = cam.Memory.GetLast(out s32LastMemId);
statusRet = cam.Memory.Lock(s32LastMemId);
statusRet = cam.Memory.GetSize(s32LastMemId, out s32Width, out s32Height);
// copy it to a bitmap
statusRet = cam.Memory.ToBitmap(s32LastMemId, out bitmap_Current);
// Scale down the bitmap
Bitmap bitmap_Temp = new Bitmap(bitmap_Current, pictBox_Current.Width, pictBox_Current.Height);
// clone it
bitmap_CurrentRed = bitmap_Temp.Clone(rectRed, pixelformat);
// Display it
pictBox_Current.Image = bitmap_CurrentRed;
// unlock image buffer
statusRet = cam.Memory.Unlock(s32LastMemId);
bitmap_Temp.Dispose();
}
public static CameraResults InitializeCamera()
{
Camera = new uEye.Camera();
CameraStatus = new CameraResults();
statusRet = Camera.Init(1);
if (statusRet != uEye.Defines.Status.Success)
{
CameraStatus.ErrorCode = "0x01";
CameraStatus.Status = "Error";
CameraStatus.ErrorDescription = "Can not be initialized uEye camera. Please check the camera connection, and try again!";
return(CameraStatus);
}
statusRet = Camera.IO.Pwm.SetMode(0);
statusRet = Camera.Memory.Allocate();
if (statusRet != uEye.Defines.Status.Success)
{
CameraStatus.ErrorCode = "0x02";
CameraStatus.Status = "Error";
CameraStatus.ErrorDescription = "Can not be allocate memory to uEye camera. Please check the camera connection, and try again!";
return(CameraStatus);
}
else
{
CameraStatus.ErrorCode = "";
CameraStatus.Status = "Initialized";
CameraStatus.ErrorDescription = "";
return(CameraStatus);
}
}
public SnapshotRetriever(CameraSummary summary, long deviceId)
{
this.summary = summary;
camera.EventFrame += camera_EventFrame;
camera.EventDeviceRemove += camera_EventDeviceRemove;
camera.EventDeviceUnPlugged += camera_EventDeviceUnPlugged;
try
{
uEye.Defines.Status status = camera.Init((Int32)deviceId | (Int32)uEye.Defines.DeviceEnumeration.UseDeviceID);
if (status != uEye.Defines.Status.SUCCESS)
{
log.ErrorFormat("Camera {0} could not be opened for thumbnail capture.", summary.Alias);
return;
}
// We do not load the camera-specific profile for the thumbnail at the moment.
// For some reason the .ToBitmap method doesn't work well on the RGB32 format, so in order to at least have something we
// load the camera on the default profile for the thumbnail.
//ProfileHelper.Load(camera, ProfileHelper.GetProfileFilename(summary.Identifier));
status = camera.Memory.Allocate();
if (status != uEye.Defines.Status.SUCCESS)
{
log.ErrorFormat("Camera {0} could not have its buffer allocated for thumbnail capture.", summary.Alias);
return;
}
}
catch (Exception e)
{
LogError(e, "");
}
}
public void SetRGBGain(Int32 r, Int32 g, Int32 b)
{
{
uEye.Defines.Status stat = this._camera.Gain.Hardware.Factor.SetRed(r);
if (stat != uEye.Defines.Status.Success)
{
throw new Exception("failed to set red gain.");
}
}
{
uEye.Defines.Status stat = this._camera.Gain.Hardware.Factor.SetGreen(g);
if (stat != uEye.Defines.Status.Success)
{
throw new Exception("failed to set green gain.");
}
}
{
uEye.Defines.Status stat = this._camera.Gain.Hardware.Factor.SetBlue(b);
if (stat != uEye.Defines.Status.Success)
{
throw new Exception("failed to set blue gain.");
}
}
OnSensorParameterChanged();
}
public static uEye.Defines.Status FreeImageMems(uEye.Camera Camera)
{
int[] idList;
uEye.Defines.Status statusRet = Camera.Memory.GetList(out idList);
if (uEye.Defines.Status.SUCCESS == statusRet)
{
foreach (int nMemID in idList)
{
do
{
statusRet = Camera.Memory.Free(nMemID);
if (uEye.Defines.Status.SEQ_BUFFER_IS_LOCKED == statusRet)
{
Thread.Sleep(1);
continue;
}
break;
}while (true);
}
}
return(statusRet);
}
public Bitmap GetBitmap()
{
uEye.Defines.Status statusRet = 0;
// Get last image memory
Int32 s32LastMemId;
Int32 s32Width;
Int32 s32Height;
statusRet = m_Camera.Memory.GetLast(out s32LastMemId);
statusRet = m_Camera.Memory.Lock(s32LastMemId);
statusRet = m_Camera.Memory.GetSize(s32LastMemId, out s32Width, out s32Height);
Bitmap MyBitmap;
statusRet = m_Camera.Memory.ToBitmap(s32LastMemId, out MyBitmap);
// clone bitmap
Rectangle cloneRect = new Rectangle(0, 0, s32Width, s32Height);
System.Drawing.Imaging.PixelFormat format = System.Drawing.Imaging.PixelFormat.Format32bppArgb;
Bitmap cloneBitmap = MyBitmap.Clone(cloneRect, format);
// unlock image buffer
statusRet = m_Camera.Memory.Unlock(s32LastMemId);
MyBitmap.Dispose();
return(cloneBitmap);
}
private void InitCamera()
{
Camera = new uEye.Camera();
uEye.Defines.Status statusRet = 0;
statusRet = Camera.Init();
if (statusRet != uEye.Defines.Status.Success)
{
MessageBox.Show("Camera initializing failed");
Environment.Exit(-1);
}
// Camera.Parameter.Load();
Camera.Trigger.Set(uEye.Defines.TriggerMode.Software);
statusRet = Camera.Focus.Auto.SetEnable(true);
if (statusRet == uEye.Defines.Status.Success)
{
showLog("自动对焦成功");
}
uEye.Types.ImageFormatInfo[] list;
Camera.Size.ImageFormat.GetList(out list);
Camera.PixelFormat.Set(uEye.Defines.ColorMode.BGR8Packed);
uint formatId = (uint)list[0].FormatID;
Camera.Size.ImageFormat.Set(formatId);
statusRet = Camera.Memory.Allocate();
// Camera.Focus.Zone.SetAOI(new Rectangle(new Point(1100, 636), new Size(672, 596)));
if (statusRet != uEye.Defines.Status.Success)
{
MessageBox.Show("Allocate Memory failed");
Environment.Exit(-1);
}
Camera.EventFrame += onFrameEvent;
Camera.EventAutoBrightnessFinished += onAutoShutterFinished;
Camera.AutoFeatures.Software.WhiteBalance.Enabled = false;
//Camera.Timing.Expoure.Set(80);
Camera.Focus.Auto.Enabled = true;
Camera.AutoFeatures.Software.Gain.Enabled = false;
statusRet = Camera.AutoFeatures.Sensor.GainShutter.SetEnable(false);
if (statusRet != uEye.Defines.Status.Success)
{
MessageBox.Show("自动曝光设置关闭失败");
Environment.Exit(-1);
}
statusRet = Camera.Timing.Exposure.Set(32);
if (statusRet != uEye.Defines.Status.Success)
{
MessageBox.Show("曝光设置失败");
Environment.Exit(-1);
}
// CB_Auto_Gain_Balance.Enabled = Camera.AutoFeatures.Software.Gain.Supported;
// CB_Auto_White_Balance.Enabled = Camera.AutoFeatures.Software.WhiteBalance.Supported;
}
//Function to initialize camera
private uEye.Defines.Status CameraInit(Int32 camID)
{
uEye.Defines.Status statusRet = uEye.Defines.Status.NO_SUCCESS;
statusRet = m_Camera.Init(camID | (Int32)uEye.Defines.DeviceEnumeration.UseDeviceID);
//check if camera initialized well and there is enough memory
if (statusRet != uEye.Defines.Status.SUCCESS)
{
MessageBox.Show("Initializing the Camera Failed");
return(statusRet);
}
statusRet = m_Camera.Memory.Allocate();
if (statusRet != uEye.Defines.Status.SUCCESS)
{
MessageBox.Show("Allocating Memory Failed");
return(statusRet);
}
//if we have to move the mirrors
if (pulsePal != null)
{
//move mirrors when new frame is captured: this triggering serves
//the porpuse of not moving the mirrors during frame acquisition
m_Camera.EventFirstPacket += TriggerMirror;
}
//reset the frame count
m_s32FrameCoutTotal = 0;
m_Camera.Video.ResetCount();
return(statusRet);
}
public void StartCapture()
{
uEye.Defines.Status stat = _camera.Acquisition.Capture();
if (stat != uEye.Defines.Status.Success)
{
throw new Exception("Start Live Video failed");
}
}
public override IntPtr GetLastPtr()
{
uEye.Defines.Status statusRet = 0;
// Get last image memory
IntPtr lastPtr;
statusRet = camera.Memory.GetLast(out lastPtr);
return(lastPtr);
}
private static bool isStreamFormatSupported(uEye.Camera camera, int colorMode)
{
uEye.Defines.ColorConvertMode converterMode = 0;
uEye.Defines.Status statusRet = camera.Color.Converter.GetSupported((uEye.Defines.ColorMode)colorMode, out converterMode);
// The value returned in converterMode is a bitfield of supported converters, like Hardware3x3, Software5x5, etc.
// As long as one converter is supported we should get the correct frame content. (Not sure about that JPEG converter though).
return(statusRet == uEye.Defines.Status.Success && converterMode != uEye.Defines.ColorConvertMode.None);
}
private void btn_StopLive_Click(object sender, EventArgs e)
{
// Stop the camera acquisition
uEye.Defines.Status status = ids_Camera.Acquisition.Stop();
// Refresh the status of buttons
btn_StartLive.Enabled = true;
btn_StopLive.Enabled = false;
btn_Freeze.Enabled = false;
}
public void SaveParameters(string parameters_file)
{
uEye.Defines.Status statusRet = 0;
statusRet = Camera.Parameter.Save(parameters_file);
if (statusRet != uEye.Defines.Status.SUCCESS)
{
throw new Exception("failed to save Parameters");
}
}
public void ConnectIDS(int DeviceID, string iniPath)
{
//初始化相機
nRet = m_Camera.Init(DeviceID);
Thread.Sleep(200);
LoadiniFile(iniPath);
Thread.Sleep(200);
//分配相機記憶體
nRet = m_Camera.Memory.Allocate();
//相機Frame更新時觸發
m_Camera.EventFrame += onFrameEvent;
}
// FUNCTION: InitCamera: Initialize the Camera
//
//
private void InitCamera()
{
cam = new uEye.Camera();
uEye.Defines.Status statusRet = 0;
cam.Size.ImageFormat.Set(7);
// Open Camera
statusRet = cam.Init();
if (statusRet != uEye.Defines.Status.Success)
{
MessageBox.Show("Camera initializing failed");
Environment.Exit(-1);
}
// Set Colour Mode
uEye.Types.SensorInfo SensorInfo;
statusRet = cam.Information.GetSensorInfo(out SensorInfo);
if (SensorInfo.SensorColorMode == uEye.Defines.SensorColorMode.Bayer)
{
statusRet = cam.PixelFormat.Set(uEye.Defines.ColorMode.BGR8Packed);
}
else
{
statusRet = cam.PixelFormat.Set(uEye.Defines.ColorMode.Mono8);
MessageBox.Show("Black and white?!");
Environment.Exit(-1);
}
// Allocate Memory
statusRet = cam.Memory.Allocate();
if (statusRet != uEye.Defines.Status.Success)
{
MessageBox.Show("Allocate Memory failed");
Environment.Exit(-1);
}
SetCameraParameters();
// Start Live Video
statusRet = cam.Acquisition.Capture();
if (statusRet != uEye.Defines.Status.Success)
{
MessageBox.Show("Start Live Video failed");
Environment.Exit(-1);
}
// Connect video to window
cam.EventFrame += onFrameEvent;
}
/// <summary>
/// 开始记录视频到指定avi文件
/// </summary>
/// <param name="aviFileAbsPath"></param>
/// <returns></returns>
public override bool RecordVedio(string aviFileAbsPath)
{
statusRet = camera.Video.Start(aviFileAbsPath);
if (statusRet != uEye.Defines.Status.SUCCESS)
{
SetError("Could not start video recording");
return(false);
}
else
{
return(true);
}
}
/// <summary>
/// 获取相机可设置的最大帧率
/// </summary>
/// <returns></returns>
public override double GetCameraMaxFrameRate()
{
if (camera == null)
{
return(0);
}
uEye.Defines.Status statusRet;
uEye.Types.Range <Double> range;
statusRet = camera.Timing.Framerate.GetFrameRateRange(out range);
return(range.Maximum);
}
private void expTimeNumericUpDown_ValueChanged(object sender, EventArgs e)
{
if (guiup2date) // basically mutex to stop repeated callbacks
{
guiup2date = false;
exptime = System.Convert.ToDouble(expTimeNumericUpDown.Value);
uEye.Defines.Status statusRet = 0;
statusRet = camera.Timing.Exposure.Set(exptime);
statusRet = camera.Timing.Exposure.Get(out exptime);
expTimeNumericUpDown.Value = System.Convert.ToDecimal(exptime);
expTimeTrackBar.Value = (int)((exptime - etrange.Minimum) / etrange.Increment);
guiup2date = true;
}
}
private void expTimeTrackBar_Scroll(object sender, EventArgs e)
{
if (guiup2date)
{
guiup2date = false;
exptime = expTimeTrackBar.Value * etrange.Increment + etrange.Minimum;
uEye.Defines.Status statusRet = 0;
statusRet = camera.Timing.Exposure.Set(exptime);
statusRet = camera.Timing.Exposure.Get(out exptime);
expTimeNumericUpDown.Value = System.Convert.ToDecimal(exptime);
expTimeTrackBar.Value = (int)((exptime - etrange.Minimum) / etrange.Increment);
guiup2date = true;
}
}
private void updateAOI()
{
if (guiup2date)
{
guiup2date = false;
// Use new slider values to update camera parameters
aoix0 = System.Convert.ToInt32(aoiX0NumericUpDown.Value);
aoiy0 = System.Convert.ToInt32(aoiY0NumericUpDown.Value);
aoiwidth = System.Convert.ToInt32(aoiWidthNumericUpDown.Value);
aoiheight = System.Convert.ToInt32(aoiHeightNumericUpDown.Value);
uEye.Defines.Status statusRet = 0;
statusRet = camera.Size.AOI.Set(aoix0, aoiy0, aoiwidth, aoiheight);
// ranges and position etc may have changed, update the sliders accordingly
statusRet = camera.Size.AOI.GetPosRange(out aoix0range, out aoiy0range);
statusRet = camera.Size.AOI.Get(out aoix0, out aoiy0, out aoiwidth, out aoiheight);
camStatusLabel.Text = new Rectangle(aoix0, aoiy0, aoiwidth, aoiheight).ToString();
aoiY0NumericUpDown.Maximum = aoiy0range.Maximum;
aoiY0NumericUpDown.Minimum = aoiy0range.Minimum;
aoiY0NumericUpDown.Increment = aoiy0range.Increment;
aoiY0NumericUpDown.Value = aoiy0;
aoiX0NumericUpDown.Maximum = aoix0range.Maximum;
aoiX0NumericUpDown.Minimum = aoix0range.Minimum;
aoiX0NumericUpDown.Increment = aoix0range.Increment;
aoiX0NumericUpDown.Value = aoix0;
aoiWidthNumericUpDown.Maximum = aoiwidthrange.Maximum;
aoiWidthNumericUpDown.Minimum = aoiwidthrange.Minimum;
aoiWidthNumericUpDown.Increment = aoiwidthrange.Increment;
aoiWidthNumericUpDown.Value = aoiwidth;
aoiHeightNumericUpDown.Maximum = aoiheightrange.Maximum;
aoiHeightNumericUpDown.Minimum = aoiheightrange.Minimum;
aoiHeightNumericUpDown.Increment = aoiheightrange.Increment;
aoiHeightNumericUpDown.Value = aoiheight;
aoiPictureBox.Location = new Point(aoix0 + pboxorigin.X, aoiy0 + pboxorigin.Y);
aoiPictureBox.Size = new Size(aoiwidth, aoiheight);
guiup2date = true;
}
}
public void InitCamera()
{
Camera = new uEye.Camera();
uEye.Defines.Status statusRet = 0;
// Open Camera
statusRet = Camera.Init();
if (statusRet != uEye.Defines.Status.Success)
{
//MessageBox.Show("Camera initializing failed");
Environment.Exit(-1);
}
Camera.Trigger.Set(uEye.Defines.TriggerMode.Software);
uEye.Types.ImageFormatInfo[] FormatInfoList;
Camera.Size.ImageFormat.GetList(out FormatInfoList);
int count = FormatInfoList.Count();
Camera.Size.ImageFormat.Set((uint)FormatInfoList[10].FormatID);
// Allocate Memory
statusRet = Camera.Memory.Allocate();
if (statusRet != uEye.Defines.Status.Success)
{
// MessageBox.Show("Allocate Memory failed");
Environment.Exit(-1);
}
//
//Camera.Size.ImageFormat.Set(4192*3104);
//// Start Live Video
//statusRet = Camera.Acquisition.Capture();
//if (statusRet != uEye.Defines.Status.Success)
//{
// //MessageBox.Show("Start Live Video failed");
//}
//else
//{
// bLive = true;
//}
// Connect Event
Camera.EventFrame += onFrameEvent;
}
public void AutoWhitebalanceOn()
{
uEye.Defines.Status stat = this._camera.AutoFeatures.Software.WhiteBalance.SetType(uEye.Defines.Whitebalance.Type.GreyWorld);
if (stat != uEye.Defines.Status.Success)
{
throw new Exception("failed.");
}
stat = this._camera.AutoFeatures.Software.WhiteBalance.SetEnable(uEye.Defines.ActivateMode.Once);
if (stat != uEye.Defines.Status.Success)
{
throw new Exception("failed.");
}
}
public void StopGrabContinuous()
{
if (bLive)
{
uEye.Defines.Status statusRet = 0;
Camera.Acquisition.Stop();
if (statusRet != uEye.Defines.Status.Success)
{
throw new Exception("failed to stop live");
}
IsGrabbingContinuous = false;
}
}
public static uEye.Defines.Status AllocImageMems(uEye.Camera Camera, int nCount)
{
uEye.Defines.Status statusRet = uEye.Defines.Status.SUCCESS;
for (int i = 0; i < nCount; i++)
{
statusRet = Camera.Memory.Allocate();
if (statusRet != uEye.Defines.Status.SUCCESS)
{
FreeImageMems(Camera);
}
}
return(statusRet);
}
private uEye.Defines.Status AllocImageMems()
{
uEye.Defines.Status statusRet = uEye.Defines.Status.SUCCESS;
for (int i = 0; i < m_cnNumberOfSeqBuffers; i++)
{
statusRet = m_Camera.Memory.Allocate();
if (statusRet != uEye.Defines.Status.SUCCESS)
{
FreeImageMems();
}
}
return(statusRet);
}
