/// <summary> /// Retrieve the value for a specific camera feature. /// </summary> /// <returns>The feature value.</returns> /// <param name="feature">Feature name.</param> public int GetFeature(string feature) { int result = 0; Psinc.GetFeature(this.camera, feature, out result); return(result); }
/// <summary> /// Write a block of data to a device. /// </summary> /// <returns><c>true</c>, if successful, <c>false</c> otherwise.</returns> /// <param name="device">Name of device.</param> /// <param name="buffer">Buffer to be written.</param> public bool DeviceWrite(string device, byte [] buffer) { unsafe { fixed(byte *data = buffer) { return(Psinc.DeviceWrite(this.camera, device, (IntPtr)data, buffer.Length) == (int)ReturnCodes.Ok); } } }
/// <summary> /// Read a block of data from a device /// </summary> /// <returns>The number of bytes read or 0 if unsuccessful.</returns> /// <param name="device">Name of device.</param> /// <param name="buffer">Buffer in which to write the data.</param> public int DeviceRead(string device, byte [] buffer) { int used = 0; unsafe { fixed(byte *data = buffer) { if (Psinc.DeviceRead(this.camera, device, (IntPtr)data, buffer.Length, out used) == (int)ReturnCodes.Ok) { return(used); } } } return(0); }
/// <summary> /// Grab an HDR frame from context A and B in rapid succession.Camera is restored to context A when /// complete. /// </summary> /// <returns><c>true</c>, if successful, <c>false</c> otherwise.</returns> /// <param name="imageA">Instance of image in which to write the grabbed frame for context A.</param> /// <param name="flashA">Required flash power for context A.</param> /// <param name="imageB">Instance of image in which to write the grabbed frame for context B.</param> /// <param name="flashB">Required flash power for context B.</param> public bool GrabMultiple(ImageHDR imageA, byte flashA, ImageHDR imageB, byte flashB) { bool result = false; Psinc.SetContext(this.camera, 0); Psinc.SetFlash(this.camera, flashA); if (Psinc.GrabHDR(this.camera, imageA.Pointer) == (int)ReturnCodes.Ok) { Psinc.SetContext(this.camera, 1); Psinc.SetFlash(this.camera, flashB); result = Psinc.GrabHDR(this.camera, imageB.Pointer) == (int)ReturnCodes.Ok; Psinc.SetContext(this.camera, 0); } return(result); }
/// <summary> /// Releases all resource used by the <see cref="libpsinc.Camera"/> object. /// </summary> /// <remarks>Call <see cref="Dispose"/> when you are finished using the <see cref="libpsinc.Camera"/>. The /// <see cref="Dispose"/> method leaves the <see cref="libpsinc.Camera"/> in an unusable state. After calling /// <see cref="Dispose"/>, you must release all references to the <see cref="libpsinc.Camera"/> so the garbage /// collector can reclaim the memory that the <see cref="libpsinc.Camera"/> was occupying.</remarks> public void Dispose() { Psinc.Delete(this.camera); }
/// <summary> /// Initializes a new instance of the <see cref="libpsinc.Camera"/> class. /// </summary> public Camera() { this.camera = Psinc.Create(); }
/// <summary> /// Enable logging to the console with "info" level verbosity. Only /// necessary to call this once at the start of an application. /// </summary> public static void EnableLogging() { Psinc.EnableLogging(); }
/// <summary> /// Write a single byte to a device. /// </summary> /// <returns><c>true</c>, if successful, <c>false</c> otherwise.</returns> /// <param name="device">Name of device.</param> /// <param name="value">Value to transmit.</param> public bool DeviceWrite(string device, byte value) { return(Psinc.DeviceWriteByte(this.camera, device, value) == (int)ReturnCodes.Ok); }
/// <summary> /// Send an initialisation value to a device /// </summary> /// <returns><c>true</c>, if successful, <c>false</c> otherwise.</returns> /// <param name="device">Name of device.</param> /// <param name="configuration">Configuration value.</param> public bool DeviceInitialise(string device, byte configuration) { return(Psinc.DeviceInitialise(this.camera, device, configuration) == (int)ReturnCodes.Ok); }
/// <summary> /// Set the camera context (where supported). /// </summary> /// <param name="context">Context index.</param> public bool SetContext(byte context) { return(Psinc.SetContext(this.camera, context) == (int)ReturnCodes.Ok); }
/// <summary> /// Sets the flash power (0 for disabled). /// </summary> /// <param name="power">Power level.</param> public bool SetFlash(byte power) { return(Psinc.SetFlash(this.camera, power) == (int)ReturnCodes.Ok); }
/// <summary> /// Set a specific camera feature to the given value. /// </summary> /// <param name="feature">Feature name.</param> /// <param name="value">Value to set</param> public bool SetFeature(string feature, int value) { return(Psinc.SetFeature(this.camera, feature, value) == (int)ReturnCodes.Ok); }
/// <summary> /// Grab an HDR frame and write to the supplied image instance. This function blocks until /// an image has been grabbed or an error occurrs. /// </summary> /// <returns>True if a camera was connected and an image was succesfully grabbed.</returns> /// <param name="image">Instance of image in which to write the grabbed frame.</param> public bool Grab(ImageHDR image) { return(Psinc.GrabHDR(this.camera, image.Pointer) == (int)ReturnCodes.Ok); }
/// <summary> /// Initialise the camera and instruct it to connect to a specific camera. /// </summary> /// <param name="serial"> /// An empty serial number will instruct it to connect to the first /// camera it can find. The serial number supports regular expressions and can therefore /// be used to connect to a specific ID regardless of serial number, for example ".*:primary" /// where the ID of the camera has been set to "primary". /// </param> public void Initialise(string serial) { Psinc.Initialise(this.camera, serial); }