VIDAR Scanner problem with PInvoke

EDN Admin · May 31, 2012

Hi everyone, 
I am having problems creating a C# interface with a C++ API for Vidar Scanners.
Here is the code Im using:
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Runtime.InteropServices;
namespace Novarad.Common.Multimedia.Scanning { 
public class VidarScanning { 
// Import the methods from the unmanaged code 
 
// for x86 apps on x64 machine 
[DllImport("Vscsi32.dll", EntryPoint = "findDigitizer", CallingConvention = CallingConvention.Cdecl)] 
//public static extern long findDigitizer(unsigned char *digitizerName, unsigned short *host_adapter_ID, unsigned short *scsi_ID); 
public static extern unsafe Int32 findDigitizerX86_X64(void* digitizerName, ref ushort host_adapter_ID, ref ushort scsi_ID); 
[DllImport("Vscsi32.dll", EntryPoint = "getDigitizerInfo", CallingConvention = CallingConvention.Cdecl)] 
//public static extern long getDigitizerInfo(DIGITIZERINFO* pDI); 
public static extern unsafe Int32 getDigitizerInfoX86_X64(ref DigitizerInfo pDI); 
[DllImport("Vscsi32.dll", EntryPoint = "Scan", CallingConvention = CallingConvention.Cdecl)] 
//public static extern long Scan(DIGITIZERINFO *di, SCANPARAMETERS *sp, unsigned char **image_buffer, unsigned long *total_bytes_received); 
public static extern unsafe Int32 ScanX86_X64(ref DigitizerInfo di, ref ScanParameters sp, void* image_buffer, ref UInt32 total_bytes_received); 
[DllImport("Vscsi32.dll", EntryPoint = "getVidarError", CallingConvention = CallingConvention.Cdecl)] 
//public static extern short getVidarError(long Err, VIDARERRORINFO* ErrInfo, unsigned short* ErrCount); 
public static extern unsafe short getVidarErrorX86_X64(Int32 Err, ref ErrorInfo ErrInfo, ref ushort ErrCount); 
[DllImport("Vscsi32.dll", EntryPoint = "StartLogging", CallingConvention = CallingConvention.Cdecl)] 
public static extern unsafe short StartLoggingX86_X64(); 
[DllImport("Vscsi32.dll", EntryPoint = "StopLogging", CallingConvention = CallingConvention.Cdecl)] 
public static extern unsafe short StopLoggingX86_X64();
// Layout and define the managed structures 
[StructLayout(LayoutKind.Sequential)] 
public struct DigitizerInfo { 
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 20)] 
public ushort[] resolutions; 
public ushort resolutionsCount; 
public ushort currentResolution; 
public ushort opticalResolution; 
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)] 
public ushort[] bitDepths; 
public ushort bitDepthsCount; 
public ushort currentBitDepth; 
public float maxWidth; 
public ushort lineTime; 
public ushort lineTimeStart; 
public ushort lineTimeEnd; 
public ushort currentLineTime; 
public ushort lineTimeFixed; 
public ushort darkEnhance; 
public ushort lineFilter; 
public ushort maxFilms; 
public ushort backupFilm; 
public ushort dnldBlocks; 
public ushort translationTables; 
public ushort locationZero; 
public ushort ejectMode; 
public ushort feederType; 
public ushort digitizerModel; 
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 7)] 
public string serialNumber; 
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 5)] 
public string fwVer; 
public ushort hwVer; 
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 11)] 
public string corePsd; 
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 7)] 
public string extPswd; 
public ushort lampType; 
public ushort isPAYG; 
} 
[StructLayout(LayoutKind.Sequential)] 
public struct ScanParameters { 
public ushort bitdepth; 
public ushort resolution; 
public ushort pixel_width; 
public UInt32 pixel_length; 
public byte output_mode; 
public Int32 scan_mode; 
public ushort bit_order; 
public UInt32 bitDepthBytes; 
public ushort avgCount; 
public short transTableNum; 
public UInt32 bUseDetectedWidth; 
public UInt32 bScanDone; 
public ushort detected_pixel_width; 
public UInt32 detected_pixel_length; 
public UInt32 bScanAbort; 
public UInt32 scan_byte_count; 
public ushort Yresolution; 
public UInt32 xOffset; 
public UInt32 yOffset; 
public ushort turboMode; 
}
[StructLayout(LayoutKind.Sequential)] 
public struct ErrorInfo { 
public ushort errCode; 
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 80)] 
public string message; 
} 
} 
}
/* These are the structures as they appear in the C++ header file 
typedef struct _DIGITIZERINFO 
{ 
unsigned short resolutions[20]; 
unsigned short resolutionsCount; 
unsigned short currentResolution; 
unsigned short opticalResolution; 
unsigned short bitDepths[10]; 
unsigned short bitDepthsCount; 
unsigned short currentBitDepth; 
float maxWidth; 
unsigned short lineTime; 
unsigned short lineTimeStart; 
unsigned short lineTimeEnd; 
unsigned short currentLineTime; 
unsigned short lineTimeFixed; 
unsigned short darkEnhance; 
unsigned short lineFilter; 
unsigned short maxFilms; 
unsigned short backupFilm; 
unsigned short dnldBlocks; 
unsigned short translationTables; 
unsigned short locationZero; 
unsigned short ejectMode; 
unsigned short feederType; 
unsigned short digitizerModel; 
unsigned char serialNumber[7]; 
unsigned char fwVer[5]; 
unsigned short hwVer; 
unsigned char corePswd[11]; 
unsigned char extPswd[7]; 
unsigned short lampType; 
unsigned short isPAYG; 
} DIGITIZERINFO; 
typedef struct _SCANPARAMETERS 
{ 
unsigned short bitdepth; 
unsigned short resolution; 
unsigned short pixel_width; 
unsigned long pixel_length; 
unsigned char output_mode; 
int scan_mode; 
unsigned short bit_order; 
unsigned long bitDepthBytes; 
unsigned short avgCount; 
short transTableNum; 
unsigned int bUseDetectedWidth; 
unsigned int bScanDone; 
unsigned short detected_pixel_width; 
unsigned long detected_pixel_length; 
unsigned int bScanAbort; 
unsigned int scan_byte_count; 
unsigned short Yresolution; 
unsigned long xOffset; 
unsigned long yOffset; 
unsigned short turboMode; 
} SCANPARAMETERS; 
typedef struct _VIDARERRORINFO 
{ 
unsigned short ErrCode; 
char Message[80]; 
} VIDARERRORINFO; 
*/
________________________________________________________________________________________________
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Runtime.InteropServices;
namespace Novarad.Common.Multimedia.Scanning { 
public class VidarAPIManager { 
#region consts 
public const ushort LINE_TIME_FIXED = 1; 
public const ushort DARK_ENHANCE_SUPPORTED = 1; 
public const ushort TRANS_TABLES_FULL_SET = 1; 
public const short TRANS_TABLE_ZERO_LINEAR = 0; 
public const short TRANS_TABLE_ZERO_LOG = 1; 
public const ushort EJECT_MODE_DOUBLE = 1;
#region model types 
public const ushort MODEL_UNKNOWN = 0; 
public const ushort VXR12 = 1; 
public const ushort VXR12_PLUS = 2; 
public const ushort VXR16 = 3; 
public const ushort VXR16_DOS = 4; 
public const ushort DIAG_PRO = 5; 
public const ushort DIAG_PRO_PLUS_USA = 6; 
public const ushort DIAG_PRO_PLUS_EURO = 7; 
public const ushort DIAG_PRO_M = 8; 
public const ushort SIERRA = 9; 
public const ushort SIERRA_PLUS = 10; 
public const ushort DIAG_PRO_ADVANTAGE_USA = 11; 
public const ushort DIAG_PRO_ADVANTAGE_EURO = 12; 
public const ushort DOS_PRO_ADVANTAGE = 13; 
public const ushort CAD_PRO_ADVANTAGE = 14; 
public const ushort KERNEL = 15; 
public const ushort SIERRA_ADVANTAGE = 16; 
public const ushort DENTAL_FILM_DIGITIZER = 17; 
public const ushort TELERAD_PRO = 19; 
public const ushort TELERAD_PRO_EDGE = 22; 
public const ushort VETRAD_PRO_EDGE = 23; 
#endregion model types
public const byte GRAYSCALE_8 = 4; 
public const byte GRAYSCALE_12 = 7; 
public const byte GRAYSCALE_16 = 6; 
public const Int32 SM_LINES = 0; 
public const Int32 SM_SOFTSENSOR = 1; 
public const ushort BO_MOTOROLA = 0; 
public const ushort BO_INTEL = 1; 
#endregion consts
#region private member variables 
private bool _is64BitApp = false; 
private bool _is64BitOS = false; 
private ushort _errCount = 0; 
private ushort _hostAdapterID = 0; 
private ushort _scsiID = 0; 
private UInt32 _totalBytesReceived = 0; 
private string _digitizerName = null; 
private IntPtr _imageBuffer; 
private VidarScanning.ErrorInfo _errorInfo; 
private VidarScanning.DigitizerInfo _digitizerInfo; 
private VidarScanning.ScanParameters _scanParameters; 
#endregion private member variables
#region constructors 
public VidarAPIManager() { 
_is64BitApp = Environment.Is64BitProcess; 
_is64BitOS = Environment.Is64BitOperatingSystem; 
_errorInfo = new VidarScanning.ErrorInfo(); 
_digitizerInfo = new VidarScanning.DigitizerInfo(); 
_scanParameters = new VidarScanning.ScanParameters(); 
} 
#endregion contructors
#region methods 
public unsafe bool lookForDigitizer() { 
bool success = false; 
IntPtr digNamePtr = IntPtr.Zero;
try { 
// alloc mem for digitizer pointer 
digNamePtr = Marshal.AllocHGlobal(IntPtr.Size);
// call external method 
if (_is64BitApp) { 
//getScanningError(VidarScanning.findDigitizerX64_X64(digNamePtr.ToPointer(), ref _hostAdapterID, ref _scsiID), ref _errorInfo, ref _errCount); 
} 
else if (_is64BitOS) { 
getScanningError(VidarScanning.findDigitizerX86_X64(digNamePtr.ToPointer(), ref _hostAdapterID, ref _scsiID), ref _errorInfo, ref _errCount); 
} 
else { 
//getScanningError(VidarScanning.findDigitizerX86_X86(digNamePtr.ToPointer(), ref _hostAdapterID, ref _scsiID), ref _errorInfo, ref _errCount); 
}
_digitizerName = Marshal.PtrToStringAnsi(digNamePtr); 
if (_digitizerName.Length > 1) { 
_digitizerName = _digitizerName.Substring(0, _digitizerName.IndexOf( )); 
} 
if (_errorInfo.errCode == 0) { 
success = true; 
} 
return success; 
} 
finally { 
// clean up memory 
if (digNamePtr != IntPtr.Zero) { 
Marshal.FreeHGlobal(digNamePtr); 
} 
} 
}
public unsafe bool getDigitizerInformation() { 
bool success = false;
// call external method 
if (_is64BitApp) { 
//getScanningError(VidarScanning.getDigitizerInfoX64_X64(ref _digitizerInfo), ref _errorInfo, ref _errCount); 
} 
else if (_is64BitOS) { 
getScanningError(VidarScanning.getDigitizerInfoX86_X64(ref _digitizerInfo), ref _errorInfo, ref _errCount); 
} 
else { 
//getScanningError(VidarScanning.getDigitizerInfoX86_X86(ref _digitizerInfo), ref _errorInfo, ref _errCount); 
} 
if (_errorInfo.errCode == 0) { 
success = true; 
}
return success; 
}
public unsafe bool scanImage() { 
bool success = false; 
IntPtr imgPtr = IntPtr.Zero;
try { 
// alloc mem for image buffer pointer 
imgPtr = Marshal.AllocHGlobal((int)(_scanParameters.pixel_width * _scanParameters.pixel_length * _scanParameters.bitDepthBytes));
// call external method 
if (_is64BitApp) { 
//getScanningError(VidarScanning.ScanX64_X64(ref _digitizerInfo, ref _scanParameters, imgPtr.ToPointer(), ref _totalBytesReceived), ref _errorInfo, ref _errCount); 
} 
else if (_is64BitOS) { 
getScanningError(VidarScanning.ScanX86_X64(ref _digitizerInfo, ref _scanParameters, imgPtr.ToPointer(), ref _totalBytesReceived), ref _errorInfo, ref _errCount); 
} 
else { 
//getScanningError(VidarScanning.ScanX86_X86(ref _digitizerInfo, ref _scanParameters, imgPtr.ToPointer(), ref _totalBytesReceived), ref _errorInfo, ref _errCount); 
}
_imageBuffer = Marshal.ReadIntPtr(imgPtr);
if (_errorInfo.errCode == 0) { 
success = true; 
}
return success; 
} 
finally { 
if (imgPtr != IntPtr.Zero) { 
Marshal.FreeHGlobal(imgPtr); 
} 
} 
}
private unsafe short getScanningError(Int32 error, ref VidarScanning.ErrorInfo info, ref ushort count) { 
short result = 0;
// call external method 
if (_is64BitApp) { 
//result = VidarScanning.getVidarErrorX64_X64(error, ref info, ref count); 
} 
else if (_is64BitOS) { 
result = VidarScanning.getVidarErrorX86_X64(error, ref info, ref count); 
} 
else { 
//result = VidarScanning.getVidarErrorX86_X86(error, ref info, ref count); 
} 
 
return result; 
}
public unsafe short startLogging() { 
short result = 0;
// call external method 
if (_is64BitApp) { 
//result = VidarScanning.StartLoggingX64_X64(); 
} 
else if (_is64BitOS) { 
result = VidarScanning.StartLoggingX86_X64(); 
} 
else { 
//result = VidarScanning.StartLoggingX86_X86(); 
}
return result; 
}
public unsafe short stopLogging() { 
short result = 0;
// call external method 
if (_is64BitApp) { 
//result = VidarScanning.StopLoggingX64_X64(); 
} 
else if (_is64BitOS) { 
result = VidarScanning.StopLoggingX86_X64(); 
} 
else { 
//result = VidarScanning.StopLoggingX86_X86(); 
}
return result; 
} 
#endregion methods
#region properties 
public string DigitizerName { 
get { 
return _digitizerName; 
} 
}
public ushort ErrorCount { 
get { 
return _errCount; 
} 
}
public ushort HostAdapterID { 
get { 
return _hostAdapterID; 
} 
}
public ushort SCSI_ID { 
get { 
return _scsiID; 
} 
}
public IntPtr ImageBuffer { 
get { 
return _imageBuffer; 
} 
}
public UInt32 TotalBytesReceived { 
get { 
return _totalBytesReceived; 
} 
}
public ushort[] Resolutions { // resolutions available 
get { 
ushort[] resolutions = new ushort[this.ResolutionsCount]; 
for (int i = 0; i < this.ResolutionsCount; i++) { 
resolutions = _digitizerInfo.resolutions; 
} 
return resolutions; 
} 
}
public ushort ResolutionsCount { // number of resolutions available 
get { 
return _digitizerInfo.resolutionsCount; 
} 
}
public ushort CurrentResolution { // current resolution that will be used for scanning 
get { 
return _digitizerInfo.currentResolution; 
} 
}
public ushort XResolution { 
set { 
_scanParameters.resolution = value; 
} 
get { 
return _scanParameters.resolution; 
} 
}
public ushort YResolution { 
set { 
_scanParameters.Yresolution = value; 
} 
get { 
return _scanParameters.Yresolution; 
} 
}
public ushort[] BitDepths { // bit depths available 
get { 
ushort[] bitDepths = new ushort[this.BitDepthsCount]; 
for (int i = 0; i < this.BitDepthsCount; i++) { 
bitDepths = _digitizerInfo.bitDepths; 
} 
return bitDepths; 
} 
}
public ushort BitDepthsCount { // number of bit depths available 
get { 
return _digitizerInfo.bitDepthsCount; 
} 
}
public ushort CurrentBitDepth { // current bit depth value that will be used for scanning 
get { 
return _digitizerInfo.currentBitDepth; 
} 
set { 
_scanParameters.bitdepth = value; 
} 
}
public float MaxWidth { // widest scan width possible in pixels 
get { 
return _digitizerInfo.maxWidth; 
} 
}
public ushort LineTime { // exposure time in milliseconds 
get { 
return _digitizerInfo.lineTime; 
} 
}
public ushort CurrentLineTime { // current exposure time that will be used for scanning in milliseconds 
get { 
return _digitizerInfo.currentLineTime; 
} 
}
public bool LineTimeFixed { // whether or not the line time value is fixed 
get { 
return _digitizerInfo.lineTimeFixed == LINE_TIME_FIXED; 
} 
}
public bool DarkEnhanceSupported { 
get { 
return _digitizerInfo.darkEnhance == DARK_ENHANCE_SUPPORTED; 
} 
}
public ushort MaxFilms { 
get { 
return _digitizerInfo.maxFilms; 
} 
}
public bool FullTranslationTables { 
get { 
return _digitizerInfo.translationTables == TRANS_TABLES_FULL_SET; 
} 
}
public bool LocationZeroIsLog { 
get { 
return _digitizerInfo.locationZero == TRANS_TABLE_ZERO_LOG; 
} 
}
public bool EjectModeDouble { 
get { 
return _digitizerInfo.ejectMode == EJECT_MODE_DOUBLE; 
} 
}
public string Model { 
get { 
switch (_digitizerInfo.digitizerModel) { 
case VXR12: 
return "VXR-12"; 
case VXR12_PLUS: 
return "VXR-12 plus"; 
case VXR16: 
return "VXR-16"; 
case VXR16_DOS: 
return "VXR-16 Dosimetry"; 
case DIAG_PRO: 
return "DiagnosticPRO"; 
case DIAG_PRO_PLUS_USA: 
return "DiagnosticPRO plus (USA)"; 
case DIAG_PRO_PLUS_EURO: 
return "DiagnosticPRO plus (European)"; 
case DIAG_PRO_M: 
return "DiagnosticPRO - M"; 
case SIERRA: 
return "Sierra"; 
case SIERRA_PLUS: 
return "Sierra plus"; 
case SIERRA_ADVANTAGE: 
return "Sierra Advantage"; 
case DIAG_PRO_ADVANTAGE_USA: 
return "DiagnosticPRO Advantage (USA)"; 
case DIAG_PRO_ADVANTAGE_EURO: 
return "DiagnosticPRO Advantage (European)"; 
case DOS_PRO_ADVANTAGE: 
return "DosimetryPRO Advantage"; 
case CAD_PRO_ADVANTAGE: 
return "CAD PRO Advantage"; 
case DENTAL_FILM_DIGITIZER: 
return "Dental Film Digitizer"; 
case TELERAD_PRO: 
return "TeleradPRO"; 
case TELERAD_PRO_EDGE: 
return "TeleradPRO Edge"; 
case VETRAD_PRO_EDGE: 
return "VETradPRO Edge"; 
case KERNEL: 
return "Kernel mode"; 
case MODEL_UNKNOWN: 
default: 
return "Unknown Model"; 
} 
} 
}
public string SerialNumber { 
get { 
return _digitizerInfo.serialNumber; 
} 
}
public string FirmwareVersion { 
get { 
return _digitizerInfo.fwVer; 
} 
}
public ushort HardwareVersion { 
get { 
return _digitizerInfo.hwVer; 
} 
}
public string CorePassword { 
get { 
return _digitizerInfo.corePsd; 
} 
}
public string ExtendedPassword { 
get { 
return _digitizerInfo.extPswd; 
} 
}
public ushort PixelWidth { 
set { 
_scanParameters.pixel_width = value; 
} 
}
public UInt32 PixelLength { 
set { 
_scanParameters.pixel_length = value; 
} 
}
public byte OutputMode { 
set { 
_scanParameters.output_mode = value; 
} 
}
public Int32 ScanMode { 
set { 
_scanParameters.scan_mode = value; 
} 
}
public ushort BitOrder { 
set { 
_scanParameters.bit_order = value; 
} 
}
public UInt32 BitDepthBytes { 
set { 
_scanParameters.bitDepthBytes = value; 
} 
}
public ushort AvgCount { 
set { 
_scanParameters.avgCount = value; 
} 
}
public short TransTableNum { 
set { 
_scanParameters.transTableNum = value; 
} 
}
public bool UseDetectedWidth { 
set { 
if (value == true) { 
_scanParameters.bUseDetectedWidth = 1; 
} 
else { 
_scanParameters.bUseDetectedWidth = 0; 
} 
} 
}
public bool ScanDone { 
get { 
if (_scanParameters.bScanDone == 1) { 
return true; 
} 
else { 
return false; 
} 
} 
}
public ushort DetectedPixelWidth { 
get { 
return _scanParameters.detected_pixel_width; 
} 
}
public UInt32 DetectedPixelLength { 
get { 
return _scanParameters.detected_pixel_length; 
} 
}
public bool AbortScan { 
set { 
if (value) { 
_scanParameters.bScanAbort = 1; 
} 
else { 
_scanParameters.bScanAbort = 0; 
} 
} 
}
public UInt32 ScanByteCount { 
get { 
return _scanParameters.scan_byte_count; 
} 
}
public string ErrorMessage { 
get { 
return _errorInfo.message; 
} 
}
public ushort ErrorCode { 
get { 
return _errorInfo.errCode; 
} 
} 
#endregion properties 
} 
}
__________________________________________________________________________________
// Heres the code that calls the methods 
VidarAPIManager vidarManager = new VidarAPIManager(); 
SetupVidarAPIEnvironment(vidarManager); 
vidarManager.scanImage();
private void SetupVidarAPIEnvironment(VidarAPIManager vidarManager) { 
try { 
if (vidarManager.lookForDigitizer()) { 
if (vidarManager.getDigitizerInformation()) { 
// setup Vidar scan parameters
// set bitdepth, output mode, and bitDepthBytes 
bool has16Bit = false; 
bool has12Bit = false; 
bool has8Bit = false; 
for (int i = 0; i < vidarManager.BitDepthsCount; i++) { 
if (vidarManager.BitDepths == 16) { 
has16Bit = true; 
} 
else if (vidarManager.BitDepths == 12) { 
has12Bit = true; 
} 
else if (vidarManager.BitDepths == 8) { 
has8Bit = true; 
} 
} 
if (_currentProfile.Use16Bit) { 
if (has16Bit) { // use 16-bit if available 
vidarManager.CurrentBitDepth = 16; 
vidarManager.BitDepthBytes = 2; 
if (_currentProfile.ForceGrayscale) { 
vidarManager.OutputMode = VidarAPIManager.GRAYSCALE_16; 
} 
} 
else if (has12Bit) { // otherwise use 12-bit if available 
vidarManager.CurrentBitDepth = 12; 
vidarManager.BitDepthBytes = 2; 
if (_currentProfile.ForceGrayscale) { 
vidarManager.OutputMode = VidarAPIManager.GRAYSCALE_12; 
} 
} 
else if (has8Bit) { // we must use 8-bit if available 
vidarManager.CurrentBitDepth = 8; 
vidarManager.BitDepthBytes = 1; 
if (_currentProfile.ForceGrayscale) { 
vidarManager.OutputMode = VidarAPIManager.GRAYSCALE_8; 
} 
} 
else { 
throw new Exception("Scanner does not support 8-, 12- or 16-bit depths."); 
} 
} 
else { 
if (has8Bit) { // use 8-bit if available 
vidarManager.CurrentBitDepth = 8; 
vidarManager.BitDepthBytes = 1; 
if (_currentProfile.ForceGrayscale) { 
vidarManager.OutputMode = VidarAPIManager.GRAYSCALE_8; 
} 
} 
else if (has16Bit) { // otherwise use 16-bit if available 
vidarManager.CurrentBitDepth = 16; 
vidarManager.BitDepthBytes = 2; 
if (_currentProfile.ForceGrayscale) { 
vidarManager.OutputMode = VidarAPIManager.GRAYSCALE_16; 
} 
} 
else if (has12Bit) { 
vidarManager.CurrentBitDepth = 12; 
vidarManager.BitDepthBytes = 2; 
if (_currentProfile.ForceGrayscale) { 
vidarManager.OutputMode = VidarAPIManager.GRAYSCALE_12; 
} 
} 
else { 
throw new Exception("Scanner does not support 8-, 12- or 16-bit depths."); 
} 
} 
 
// set resolution 
ushort highestSupportedResolution = 0; 
for (int i = 0; i < vidarManager.ResolutionsCount; i++) { 
if (vidarManager.Resolutions > highestSupportedResolution) { 
highestSupportedResolution = vidarManager.Resolutions; 
} 
} 
vidarManager.XResolution = highestSupportedResolution; 
vidarManager.YResolution = highestSupportedResolution;
// set scan mode 
//vidarManager.ScanMode = VidarAPIManager.SM_SOFTSENSOR | VidarAPIManager.SM_LINES; 
vidarManager.ScanMode = VidarAPIManager.SM_SOFTSENSOR | VidarAPIManager.SM_LINES;
// set bit order 
vidarManager.BitOrder = VidarAPIManager.BO_MOTOROLA;
// set avgCount 
vidarManager.AvgCount = 1;
// set trans table number 
vidarManager.TransTableNum = vidarManager.LocationZeroIsLog ? VidarAPIManager.TRANS_TABLE_ZERO_LOG : VidarAPIManager.TRANS_TABLE_ZERO_LINEAR;
// set pixel width to auto detect 
vidarManager.UseDetectedWidth = true; 
vidarManager.PixelWidth = (ushort)(vidarManager.XResolution * 14); 
vidarManager.PixelLength = (uint)(vidarManager.YResolution * 17);
} 
else { 
throw new Exception(string.Format("Failed to retrieve Vidar Scanner information. Vidar Error Code: {0}, Error Message: {1}", vidarManager.ErrorCode.ToString(), vidarManager.ErrorMessage)); 
} 
} 
else { 
throw new Exception(string.Format("Failed to find a Vidar Scanner. Vidar Error Code: {0}, Error Message: {1}", vidarManager.ErrorCode.ToString(), vidarManager.ErrorMessage)); 
} 
} 
catch (Exception ex) { 
throw new Exception(Strings.VidarEnvironmentSetupFailed, ex); 
} 
}
Now, I can get the calls to lookForDigitizer() and getDigitizerInformation() and getScanningError() to work fine, but when I call ScanImage() the code gets stuck when it calls VidarScanning.ScanX86_X64() and never returns. The scanner even appears to be
scanning, but it never returns from the method. Do you think its a problem with some of the datatypes Ive used in the C# code? Or maybe the image buffer was created improperly? Any help would be greatly appreciated. Im pulling my hair out trying to get
this working. <hr class="sig Aaron Sellers

View the full article

VIDAR Scanner problem with PInvoke

EDN Admin

Well-known member

Similar threads