// Update methods
private async void UpdateScannerInfo()
{
while (SelectedScanner == null)
{
try
{
SelectedScanner = await ImageScanner.FromIdAsync(_selectedDevice.Id);
ScannerSources = ScannerHelper.GetSupportedScanSources(SelectedScanner);
UIIsScannerSelected = true;
}
catch (Exception ex)
{
// https://stackoverflow.com/questions/15772373/error-code-when-trying-to-connect-to-a-scanner-using-wpf
Debug.WriteLine("MainViewModel - Scanner is busy");
Debug.WriteLine(ex);
}
}
// Set the default properties
var defaultScannerSource = SelectedScanner.DefaultScanSource;
if (ScannerSources.Contains(defaultScannerSource))
{
SelectedScannerSource = defaultScannerSource;
}
}
public async Task <ScanSourceDetails> GetSupportedScanSources
(String deviceId)
{
// Check whether each of the known scan sources is available
// for the scanner with the provided ID
var scanSources = new[]
{
ImageScannerScanSource.Flatbed,
ImageScannerScanSource.Feeder,
ImageScannerScanSource.AutoConfigured
};
var scanner = await ImageScanner.FromIdAsync(deviceId);
var supportedSources = scanSources
.Where(x => scanner.IsScanSourceSupported(x))
.Select(x => new ScanSourceDetailsItem
{
SourceType = x,
SupportsPreview = scanner.IsPreviewSupported(x)
})
.ToList();
var results = new ScanSourceDetails
{
SupportedScanSources = supportedSources,
DefaultScanSource = scanner.DefaultScanSource
};
return(results);
}
/// <summary>
/// Process video, the worker thread
/// </summary>
private void ProcessVideo()
{
using (Video video = new Video()){
try{
video.Open(this.currentDevice);
video.Enabled = true;
using (ImageScanner scanner = new ImageScanner()){
scanner.Cache = true;
this.CaptureVideo(video, scanner);
}
video.Enabled = false;
}
catch (ZBarException ex) {
lock (this.drawLock){
this.toDraw = null;
this.symbols = null;
}
GLib.IdleHandler hdl = delegate(){
if (this.Stopped != null)
{
this.Stopped(this, new EventArgs());
}
if (this.Error != null)
{
this.Error(this, new ErrorEventArgs(ex.Message, ex));
}
this.QueueDraw();
return(false);
};
GLib.Idle.Add(hdl);
}
}
}
public async Task <IEnumerable <ScannerModel> > GetScannersAsync()
{
// String to be used to enumerate scanners
var deviceSelector = ImageScanner.GetDeviceSelector();
var scanners = await DeviceInformation.FindAllAsync(deviceSelector);
var result = scanners
.Select(x => new ScannerModel
{
Id = x.Id,
Name = x.Name,
IsDefault = x.IsDefault,
IsEnabled = x.IsEnabled,
});
return(result);
// Alternatively, a watcher can be used, which raises events as items are located/added/removed/updated:
//var watcher = DeviceInformation.CreateWatcher(deviceSelector);
//watcher.EnumerationCompleted += (sender, args) => Debug.WriteLine("Scanners enumerated");
//watcher.Added += (sender, args) => Debug.WriteLine("Scanner added - {0}", args.Name);
//watcher.Removed += (sender, args) => Debug.WriteLine("Scanner removed - {0}", args.Id);
//watcher.Updated += (sender, args) => Debug.WriteLine("Scanner updated - {0}", args.Id);
//watcher.Start();
}
public async Task <IEnumerable <StorageFile> > ScanPicturesAsync(
String scannerDeviceId, ImageScannerScanSource source,
StorageFolder destinationFolder,
Double hScanPercent, Double vScanPercent)
{
var scanner = await ImageScanner.FromIdAsync(scannerDeviceId);
if (scanner.IsScanSourceSupported(source))
{
ConfigureScanner(scanner, source, hScanPercent, vScanPercent);
var scanResult = await scanner
.ScanFilesToFolderAsync(source, destinationFolder);
var results = new List <StorageFile>();
// Caution - enumerating this list (foreach) will result in a
// COM exception. Instead, just walk the collection by index
// and build a new list.
for (var i = 0; i < scanResult.ScannedFiles.Count; i++)
{
results.Add(scanResult.ScannedFiles[i]);
}
return(results);
}
return(null);
}
public void Scan(Image source)
{
OCR = string.Empty;
var capture = CaptureImage(source);
if (Image == null)
{
Image = capture;
EventStream.Publish(new FileModified(Id + ".png", Image.ToBytes(ImageFormat.Png)));
}
var matcher = new AccordImageMatcher(Image);
var results = matcher.Compare(capture, 0.9f);
Exists = results.Any(each => each.Similarity >= 0.95f && Rectangle.Equals(each.Rectangle));
/*if (Exists) {
* Rectangle.SetBorderColor(1, 0, 1, 0);
* }
* else {
* Rectangle.SetBorderColor(1, 1, 0, 0);
* }*/
if (Rectangle.Width > 0 && Rectangle.Height > 0)
{
OCR = ImageScanner.ReadText(new Bitmap(Image)).Replace("\n", "");
}
UpdateLabel();
}
//识别二维码
public bool DoCheckTicket(ref string strQrCode)
{
DataTickCam data = new DataTickCam();
if (!mainWin.CapTicket(data))
{
return(false);
}
strQrCode = string.Empty;
using (Bitmap bmGray = WinCall.BitmapConvetGray(data.bm))
{
//垂直翻转
bmGray.RotateFlip(RotateFlipType.Rotate90FlipX);
using (ImageScanner scanner = new ImageScanner())
{
scanner.SetConfiguration(SymbolType.None, Config.Enable, 1);
List <Symbol> symbols = scanner.Scan(bmGray);
WinCall.TraceMessage(string.Format("***Ticket syms={0}", symbols.Count)); //! for test
foreach (var sym in symbols)
{
var symType = sym.GetType();
if (!string.IsNullOrEmpty(sym.Data))
{
strQrCode = sym.Data;
break; //只取一个结果
}
}
}
}
data.bm.Dispose();
return(false == string.IsNullOrEmpty(strQrCode));
}
private async void cmbxScanner_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
selectedDevice = (DeviceInformation)cmbxScanner.SelectedItem;
selectedScanner = await ImageScanner.FromIdAsync(selectedDevice.Id);
scannerSources = ScannerHelper.GetSupportedScanSources(selectedScanner);
cmbxScannerSource.ItemsSource = scannerSources;
}
/// <summary>
/// Scans the images from the scanner with auto configured settings
/// The scanning is allowed only if the selected scanner supports Device Auto-Configured Scanning.
/// </summary>
/// <param name="deviceId">scanner device id</param>
/// <param name="folder">the folder that receives the scanned files</param>
public async void ScanToFolder(string deviceId, StorageFolder folder)
{
try
{
// Get the scanner object for this device id
ImageScanner myScanner = await ImageScanner.FromIdAsync(deviceId);
// Check to see if the use has already cancelled the scenario
if (ModelDataContext.ScenarioRunning)
{
if (myScanner.IsScanSourceSupported(ImageScannerScanSource.AutoConfigured))
{
cancellationToken = new CancellationTokenSource();
// Set the scan file format to PNG, if available
if (myScanner.AutoConfiguration.IsFormatSupported(ImageScannerFormat.Png))
{
myScanner.AutoConfiguration.Format = ImageScannerFormat.Png;
}
rootPage.NotifyUser("Scanning", NotifyType.StatusMessage);
var progress = new Progress <UInt32>(ScanProgress);
// Scan API call to start scanning with Auto-Configured settings
var result = await myScanner.ScanFilesToFolderAsync(ImageScannerScanSource.AutoConfigured, folder).AsTask(cancellationToken.Token, progress);
ModelDataContext.ScenarioRunning = false;
if (result.ScannedFiles.Count > 0)
{
Utils.DisplayImageAndScanCompleteMessage(result.ScannedFiles, DisplayImage);
if (result.ScannedFiles.Count > 1)
{
Utils.UpdateFileListData(result.ScannedFiles, ModelDataContext);
}
}
else
{
rootPage.NotifyUser("There were no files scanned.", NotifyType.ErrorMessage);
}
}
else
{
ModelDataContext.ScenarioRunning = false;
rootPage.NotifyUser("The selected scanner does not support Device Auto-Configured Scanning.", NotifyType.ErrorMessage);
}
}
}
catch (OperationCanceledException)
{
Utils.DisplayScanCancelationMessage();
}
catch (Exception ex)
{
Utils.OnScenarioException(ex, ModelDataContext);
}
}
public void ConvertAndScanBMP()
{
System.Drawing.Image img = System.Drawing.Image.FromFile("images/barcode.bmp");
ImageScanner scanner = new ImageScanner();
List <Symbol> symbols = scanner.Scan(img);
Assert.AreEqual(1, symbols.Count, "Didn't find the symbols");
Assert.IsTrue(SymbolType.EAN13 == symbols[0].Type, "Didn't get the barcode type right");
Assert.AreEqual("0123456789012", symbols[0].Data, "Didn't read the correct barcode");
}
private static (Image, Image) ReadImage(Image image)
{
var time = Stopwatch.StartNew();
using var imageScanner = new ImageScanner(image);
var buffs = imageScanner.FindBuffs();
var debuffs = imageScanner.FindDebuffs();
time.Stop();
return(buffs, debuffs);
}
/// <summary>
/// Gets all available Image Formats for a Scan Source
/// </summary>
/// <param name="scanner"></param>
/// <param name="source"></param>
/// <returns>List with all available ImageScannerFormats for the given source</returns>
public static List <ImageScannerFormat> GetSupportedImageFormats(ImageScanner scanner, ImageScannerScanSource source)
{
List <ImageScannerFormat> availableFormats = new List <ImageScannerFormat>();
switch (source)
{
case ImageScannerScanSource.Flatbed: // Flatbed
{
foreach (ImageScannerFormat format in (ImageScannerFormat[])Enum.GetValues(typeof(ImageScannerFormat)))
{
if (scanner.FlatbedConfiguration.IsFormatSupported(format))
{
availableFormats.Add(format);
}
}
break;
}
case ImageScannerScanSource.Feeder: // Feeder
{
foreach (ImageScannerFormat format in (ImageScannerFormat[])Enum.GetValues(typeof(ImageScannerFormat)))
{
if (scanner.FeederConfiguration.IsFormatSupported(format))
{
availableFormats.Add(format);
}
}
break;
}
case ImageScannerScanSource.AutoConfigured: // Auto Configured
{
foreach (ImageScannerFormat format in (ImageScannerFormat[])Enum.GetValues(typeof(ImageScannerFormat)))
{
if (scanner.AutoConfiguration.IsFormatSupported(format))
{
availableFormats.Add(format);
}
}
break;
}
case ImageScannerScanSource.Default: // Catch the otherwise empty set by only providing Bitmap as option, as this is device independant
{
availableFormats.Add(ImageScannerFormat.DeviceIndependentBitmap);
break;
}
}
return(availableFormats);
}
/// <summary>
/// Scans image from the Flatbed source of the scanner
/// The scanning is allowed only if the selected scanner is equipped with a Flatbed
/// </summary>
/// <param name="deviceId">scanner device id</param>
/// <param name="folder">the folder that receives the scanned files</param>
public async void ScanToFolder(string deviceId, StorageFolder folder)
{
try
{
// Get the scanner object for this device id
ImageScanner myScanner = await ImageScanner.FromIdAsync(deviceId);
// Check to see if the user has already canceled the scenario
if (ModelDataContext.ScenarioRunning)
{
if (myScanner.IsScanSourceSupported(ImageScannerScanSource.Flatbed))
{
// Set the scan file format to Device Independent Bitmap (DIB)
myScanner.FlatbedConfiguration.Format = ImageScannerFormat.DeviceIndependentBitmap;
cancellationToken = new CancellationTokenSource();
rootPage.NotifyUser("Scanning", NotifyType.StatusMessage);
// Scan API call to start scanning from the Flatbed source of the scanner.
var result = await myScanner.ScanFilesToFolderAsync(ImageScannerScanSource.Flatbed, folder).AsTask(cancellationToken.Token);
ModelDataContext.ScenarioRunning = false;
if (result.ScannedFiles.Count > 0)
{
Utils.DisplayImageAndScanCompleteMessage(result.ScannedFiles, DisplayImage);
}
else
{
rootPage.NotifyUser("There are no files scanned from the Flatbed.", NotifyType.ErrorMessage);
}
}
else
{
ModelDataContext.ScenarioRunning = false;
rootPage.NotifyUser("The selected scanner does not report to be equipped with a Flatbed.", NotifyType.ErrorMessage);
}
}
}
catch (OperationCanceledException)
{
Utils.DisplayScanCancelationMessage();
}
catch (Exception ex)
{
Utils.OnScenarioException(ex, ModelDataContext);
}
}
/// <summary>
/// Gets all available Scan Sources for a scanner
/// </summary>
/// <param name="scanner"></param>
/// <returns>List with all available ImageScannerScanSources for the given scanner</returns>
public static List <ImageScannerScanSource> GetSupportedScanSources(ImageScanner scanner)
{
List <ImageScannerScanSource> availableScanSources = new List <ImageScannerScanSource>();
foreach (ImageScannerScanSource scanSource in (ImageScannerScanSource[])Enum.GetValues(typeof(ImageScannerScanSource)))
{
if (scanner.IsScanSourceSupported(scanSource))
{
if (scanSource != ImageScannerScanSource.Default) // Disabling Default as it'll only be used for getting preferences from
{
availableScanSources.Add(scanSource);
}
}
}
return(availableScanSources);
}
/// <summary>
/// Gets all available Colour Modes for a Scan Source
/// </summary>
/// <param name="scanner"></param>
/// <param name="source"></param>
/// <returns>List with all available ImageScannerColorMode for the given source</returns>
public static List <ImageScannerColorMode> GetSupportedColourModes(ImageScanner scanner, ImageScannerScanSource source)
{
List <ImageScannerColorMode> availableColorModes = new List <ImageScannerColorMode>();
switch (source)
{
case ImageScannerScanSource.Flatbed: // Flatbed
{
foreach (ImageScannerColorMode colourMode in (ImageScannerColorMode[])Enum.GetValues(typeof(ImageScannerColorMode)))
{
if (scanner.FlatbedConfiguration.IsColorModeSupported(colourMode))
{
availableColorModes.Add(colourMode);
}
}
break;
}
case ImageScannerScanSource.Feeder: // Feeder
{
foreach (ImageScannerColorMode colourMode in (ImageScannerColorMode[])Enum.GetValues(typeof(ImageScannerColorMode)))
{
if (scanner.FeederConfiguration.IsColorModeSupported(colourMode))
{
availableColorModes.Add(colourMode);
}
}
break;
}
case ImageScannerScanSource.AutoConfigured: // Auto Configured
{
// Not possible, return empty List
break;
}
case ImageScannerScanSource.Default: // Catch the otherwise empty set by only providing Bitmap as option, as this is device independant
{
// Not possible, return empty List
break;
}
}
return(availableColorModes);
}
/// <summary>
/// Scans all the images from Feeder source of the scanner
/// The scanning is allowed only if the selected scanner is equipped with a Feeder
/// </summary>
/// <param name="deviceId">scanner device id</param>
/// <param name="folder">the folder that receives the scanned files</param>
public async void ScanToFolder(string deviceId, StorageFolder folder)
{
try
{
// Get the scanner object for this device id
ImageScanner myScanner = await ImageScanner.FromIdAsync(deviceId);
// Check to see if the use has already cancelled the scenario
if (model.ScenarioRunning)
{
if (myScanner.IsScanSourceSupported(ImageScannerScanSource.Feeder))
{
// Set MaxNumberOfPages to zero to scanning all the pages that are present in the feeder
myScanner.FeederConfiguration.MaxNumberOfPages = 0;
myScanner.FeederConfiguration.Duplex = tggDuplex.IsOn;
myScanner.FeederConfiguration.PageSize = (Windows.Graphics.Printing.PrintMediaSize)model.ScannerDataContext.CurrentSize;
cancellationToken = new CancellationTokenSource();
rootPage.NotifyUser("Escaneando", NotifyType.StatusMessage);
// Scan API call to start scanning from the Feeder source of the scanner.
var operation = myScanner.ScanFilesToFolderAsync(ImageScannerScanSource.Feeder, folder);
operation.Progress = new AsyncOperationProgressHandler <ImageScannerScanResult, uint>(ScanProgress);
var result = await operation.AsTask <ImageScannerScanResult, UInt32>(cancellationToken.Token);
// Number of scanned files should be zero here since we already processed during scan progress notifications all the files that have been scanned
rootPage.NotifyUser("Escaneo completado.", NotifyType.StatusMessage);
model.ScenarioRunning = false;
}
else
{
model.ScenarioRunning = false;
rootPage.NotifyUser("El escáner seleccionado indica no tener Feeder.", NotifyType.ErrorMessage);
}
}
}
catch (OperationCanceledException ex)
{
Utils.DisplayScanCancelationMessage();
}
catch (Exception ex)
{
Utils.OnScenarioException(ex, model);
}
}
/// <summary>
/// Scans all the images from Feeder source of the scanner
/// The scanning is allowed only if the selected scanner is equipped with a Feeder
/// </summary>
/// <param name="deviceId">scanner device id</param>
/// <param name="folder">the folder that receives the scanned files</param>
public async void ScanToFolder(string deviceId, StorageFolder folder)
{
try
{
// Get the scanner object for this device id
ImageScanner myScanner = await ImageScanner.FromIdAsync(deviceId);
// Check to see if the use has already cancelled the scenario
if (ModelDataContext.ScenarioRunning)
{
if (myScanner.IsScanSourceSupported(ImageScannerScanSource.Feeder))
{
// Set MaxNumberOfPages to zero to scanning all the pages that are present in the feeder
myScanner.FeederConfiguration.MaxNumberOfPages = 0;
cancellationToken = new CancellationTokenSource();
rootPage.NotifyUser("Scanning", NotifyType.StatusMessage);
// Scan API call to start scanning from the Feeder source of the scanner.
var operation = myScanner.ScanFilesToFolderAsync(ImageScannerScanSource.Feeder, folder);
operation.Progress = new AsyncOperationProgressHandler <ImageScannerScanResult, uint>(ScanProgress);
var result = await operation.AsTask <ImageScannerScanResult, UInt32>(cancellationToken.Token);
// Number of scanned files should be zero here since we already processed during scan progress notifications all the files that have been scanned
rootPage.NotifyUser("Scanning is complete.", NotifyType.StatusMessage);
ModelDataContext.ScenarioRunning = false;
}
else
{
ModelDataContext.ScenarioRunning = false;
rootPage.NotifyUser("The selected scanner does not report to be equipped with a Feeder.", NotifyType.ErrorMessage);
}
}
}
catch (OperationCanceledException)
{
Utils.DisplayScanCancelationMessage();
}
catch (Exception ex)
{
Utils.OnScenarioException(ex, ModelDataContext);
}
}
public async Task <BitmapImage> ScanPicturePreviewAsync
(String scannerDeviceId, ImageScannerScanSource scanSource)
{
var scanner = await ImageScanner.FromIdAsync(scannerDeviceId);
if (scanner.IsPreviewSupported(scanSource))
{
var stream = new InMemoryRandomAccessStream();
var result =
await scanner.ScanPreviewToStreamAsync(scanSource, stream);
if (result.Succeeded)
{
var thumbnail = new BitmapImage();
thumbnail.SetSource(stream);
return(thumbnail);
}
}
return(null);
}
/// <summary>
/// Scans the images from the scanner with default settings
/// </summary>
/// <param name="deviceId">scanner device id</param>
/// <param name="folder">the folder that receives the scanned files</param>
public async void ScanToFolder(string deviceId, StorageFolder folder)
{
try
{
// Get the scanner object for this device id
ImageScanner myScanner = await ImageScanner.FromIdAsync(deviceId);
// Check to see if the use has already cancelled the scenario
if (ModelDataContext.ScenarioRunning)
{
cancellationToken = new CancellationTokenSource();
rootPage.NotifyUser("Scanning", NotifyType.StatusMessage);
var progress = new Progress <UInt32>(ScanProgress);
// Scan API call to start scanning
var result = await myScanner.ScanFilesToFolderAsync(ImageScannerScanSource.Default, folder).AsTask(cancellationToken.Token, progress);
ModelDataContext.ScenarioRunning = false;
if (result.ScannedFiles.Count > 0)
{
Utils.DisplayImageAndScanCompleteMessage(result.ScannedFiles, DisplayImage);
if (result.ScannedFiles.Count > 1)
{
Utils.UpdateFileListData(result.ScannedFiles, ModelDataContext);
}
}
else
{
rootPage.NotifyUser("There were no files scanned.", NotifyType.ErrorMessage);
}
}
}
catch (OperationCanceledException)
{
Utils.DisplayScanCancelationMessage();
}
catch (Exception ex)
{
Utils.OnScenarioException(ex, ModelDataContext);
}
}
public static string GetBarcode_ZBAR(string fileName)
{
string text;
using (var img = new Bitmap(fileName))
{
text = "";
if (img.Width > 0 && img.Height > 0)
{
System.Drawing.Image oBitmap = System.Drawing.Image.FromFile(fileName);
ImageScanner oImageScanner = new ImageScanner();
var symbols = oImageScanner.Scan(oBitmap);
if (symbols.Count > 0)
{
text = symbols[0].ToString();
text = text.Substring(8);
}
}
}
return(text);
}
/// <summary>
/// Previews the image from the scanner with given device id
/// The preview is allowed only if the selected scanner is equipped with a Flatbed and supports preview.
/// </summary>
/// <param name="deviceId">scanner device id</param>
/// <param name="stream">RandomAccessStream in which preview given the by the scan runtime API is kept</param>
public async void ScanPreview(string deviceId, IRandomAccessStream stream)
{
try
{
// Get the scanner object for this device id
ImageScanner myScanner = await ImageScanner.FromIdAsync(deviceId);
if (myScanner.IsScanSourceSupported(ImageScannerScanSource.Flatbed))
{
if (myScanner.IsPreviewSupported(ImageScannerScanSource.Flatbed))
{
rootPage.NotifyUser("Scanning", NotifyType.StatusMessage);
// Scan API call to get preview from the flatbed
var result = await myScanner.ScanPreviewToStreamAsync(ImageScannerScanSource.Flatbed, stream);
if (result.Succeeded)
{
Utils.SetImageSourceFromStream(stream, DisplayImage);
rootPage.NotifyUser("Preview scanning is complete. Below is the preview image.", NotifyType.StatusMessage);
}
else
{
rootPage.NotifyUser("Failed to preview from Flatbed.", NotifyType.ErrorMessage);
}
}
else
{
rootPage.NotifyUser("The selected scanner does not support preview from Flatbed.", NotifyType.ErrorMessage);
}
}
else
{
rootPage.NotifyUser("The selected scanner does not report to be equipped with a Flatbed.", NotifyType.ErrorMessage);
}
}
catch (Exception ex)
{
Utils.DisplayExceptionErrorMessage(ex);
}
}
/// <summary>
/// Detecta múltiples tags en una imagen
/// </summary>
/// <param name="image">Imagen a procesar</param>
/// <param name="showProcessedInput">Si se fija a true se muestra el resultado del procesamiento previo que
/// se realiza antes del proceso de detección de tags</param>
/// <returns>Lista de tags</returns>
public static List <Tag> detectTags(System.Drawing.Image image, bool showProcessedInput = false)
{
List <Tag> result = new List <Tag>();
// Procesamos la imagen de entrada
using (System.Drawing.Image img = image)//prepareInput(image, showProcessedInput))
{
using (ImageScanner scanner = new ImageScanner())
{
List <Symbol> symbols = scanner.Scan(img);
if (symbols != null && symbols.Count > 0)
{
// Iteramos los resultados y los transformamos a objetos Tag
foreach (Symbol symbol in symbols)
{
result.Add(new Tag(symbol));
}
}
}
}
return(result);
}
private async void OnScannerAdded(DeviceWatcher sender, DeviceInformation deviceInfo)
{
await
MainPage.Current.Dispatcher.RunAsync(
Windows.UI.Core.CoreDispatcherPriority.Normal,
() =>
{
string stuff = "test";
//MainPage.Current.NotifyUser(String.Format("Scanner with device id {0} has been added", deviceInfo.Id), NotifyType.StatusMessage);
//// search the device list for a device with a matching device id
//ScannerDataItem match = FindInList(deviceInfo.Id);
//// If we found a match then mark it as verified and return
//if (match != null)
//{
// match.Matched = true;
// return;
//}
//// Add the new element to the end of the list of devices
//AppendToList(deviceInfo);
}
);
//var library = await StorageLibrary.GetLibraryAsync(KnownLibraryId.Pictures);
//var folders = library.Folders;
StorageFolder testFolder = await StorageFolder.GetFolderFromPathAsync(@"D:\Pictures\Test");
//ImageScanner myScanner = await ImageScanner.FromIdAsync(deviceId);
//4D36E967-E325-11CE-BFC1-08002BE10318
ImageScanner myScanner = await ImageScanner.FromIdAsync(deviceInfo.Id);
var result = await myScanner.ScanFilesToFolderAsync(ImageScannerScanSource.Default, testFolder);
}
public void ScanCode(System.Drawing.Image image)
{
ZBar.ImageScanner scanner = new ImageScanner();
scanner.Scan(image);
List <ZBar.Symbol> symbols = new List <Symbol>();
ZXing.OneD.Code93Reader reader3 = new ZXing.OneD.Code93Reader();
reader.ResultFound += Reader_ResultFound;
if (symbols != null && symbols.Count > 0)
{
string r = string.Empty;
foreach (var s in symbols)
{
textBox1.Text = s.Data;
}
}
//ZBar.ImageScanner scanner= new ImageScanner();
//scanner.SetConfiguration(ZBar.SymbolType.None, ZBar.Config.Enable, 0);
//scanner.SetConfiguration(ZBar.SymbolType.CODE39, ZBar.Config.Enable, 1);
//scanner.SetConfiguration(ZBar.SymbolType.CODE128, ZBar.Config.Enable, 1);
//List<ZBar.Symbol> symbols = new List<Symbol>();
//symbols = scanner.Scan(image);
//if (symbols!=null&&symbols.Count>0) {
// string result = string.Empty;
// foreach (var s in symbols) {
// textBox1.Text=s.Data;
// }
//}
Result result = reader.Decode((Bitmap)image);
foreach (var point in result.ResultPoints)
{
Bitmap bitmap = new Bitmap(image);
// panel1.DrawToBitmap(bitmap, new Rectangle(new Point((int)point.X,(int)point.Y), new Size(result.)));
panel1.BackgroundImage = bitmap;
}
textBox1.Text = result.Text;
}
private void UpdateDebuff()
{
var image = _gameWindowCapturer.GetBitmapFromGameWindow();
if (image != null)
{
using var imageScanner = new ImageScanner(image);
var debuffs = imageScanner.FindDebuffs();
if (debuffs != null)
{
var source = ConvertToImageSource(debuffs);
PositionWindow(debuffs);
DebuffImage.Source = source;
debuffs.Dispose();
return;
}
}
// Set to 0 size if we don't have anything to show
DebuffImage.Width = 0;
DebuffImage.Height = 0;
}
public void Run(string[] args, string tutRoot)
{
Help();
// Default arguments
// Image digits.png is of dimension 2000x1000
string imageName = $"{tutRoot}data\\digits.png";
string argDivideWith = "10";
string imageReadType = "";
if (args.Length == 2)
{
imageName = args[0];
argDivideWith = args[1];
imageReadType = "G";
}
else if (args.Length == 3)
{
imageName = args[0];
argDivideWith = args[1];
imageReadType = args[2];
}
Mat I, J;
try
{
if (imageReadType == "G")
{
I = new Mat(imageName, ImreadModes.GrayScale);
}
else
{
I = new Mat(imageName, ImreadModes.Color);
}
}
catch (FileNotFoundException e)
{
Console.WriteLine($"The image {imageName} could not be found.");
Cv2.WaitKey();
return;
}
if (I.Empty())
{
Console.WriteLine($"The image {imageName} could not be loaded.");
Cv2.WaitKey();
return;
}
// [divideWith] Create a look-up table based on the divideWith value
int divideWith = int.Parse(argDivideWith);
if (divideWith == 0)
{
Console.WriteLine("Invalid number entered for dividing.");
Cv2.WaitKey();
return;
}
byte[] table = new byte[256];
for (int i = 0; i < 256; ++i)
{
table[i] = (byte)(divideWith * (i / divideWith));
}
// [divideWith] ================================================
const int times = 100;
double t = Cv2.GetTickCount();
for (int i = 0; i < times; ++i)
{
Mat clone_i = I.Clone();
J = ImageScanner.ScanImageAndReduceC(clone_i, table);
}
t = 1000 * (Cv2.GetTickCount() - t) / Cv2.GetTickFrequency();
t /= times;
Console.WriteLine($"\nTime of reducing with the C " +
$"operator [] (averaged for {times} runs): {t} milliseconds.");
t = Cv2.GetTickCount();
for (int i = 0; i < times; ++i)
{
Mat clone_i = I.Clone();
J = ImageScanner.ScanImageAndReduceForEach(clone_i, table);
}
t = 1000 * (Cv2.GetTickCount() - t) / Cv2.GetTickFrequency();
t /= times;
Console.WriteLine($"Time of reducing with foreach " +
$"(averaged for {times} runs): {t} milliseconds.");
t = Cv2.GetTickCount();
for (int i = 0; i < times; ++i)
{
Mat clone_i = I.Clone();
ImageScanner.ScanImageAndReduceRandomAccess(clone_i, table);
}
t = 1000 * (Cv2.GetTickCount() - t) / Cv2.GetTickFrequency();
t /= times;
Console.WriteLine($"Time of reducing with the on-the-fly address generation - " +
$"at function (averaged for {times} runs): {t} milliseconds.");
t = Cv2.GetTickCount();
for (int i = 0; i < times; ++i)
{
//! [table-use]
J = I.LUT(table);
}
//! [table-use]
t = 1000 * (Cv2.GetTickCount() - t) / Cv2.GetTickFrequency();
t /= times;
Console.WriteLine($"Time of reducing with the LUT function " +
$"(averaged for {times} runs): {t} milliseconds.");
Cv2.WaitKey();
}
/// <summary> 初始化商品扫描，初始化条码扫描类
/// </summary>
public CheckGoods()
{
CodeReader = new BarcodeReader(); //初始化ZXing条码扫描类
CodeReader.Options.CharacterSet = "UTF-8"; //设置条码字符集类型为UTF-8
CodeReader_2 = new ImageScanner(); //初始化ZBar条码扫描类
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// CONSTRUCTORS / FACTORIES /////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public DiscoveredScanner(ImageScanner device, string name)
{
Device = device;
Id = Device.DeviceId;
Name = name;
try
{
IsAutoAllowed = device.IsScanSourceSupported(ImageScannerScanSource.AutoConfigured);
IsFeederAllowed = device.IsScanSourceSupported(ImageScannerScanSource.Feeder);
IsFlatbedAllowed = device.IsScanSourceSupported(ImageScannerScanSource.Flatbed);
}
catch (Exception exc)
{
LogService.Log.Error(exc, "DiscoveredScanner: Couldn't determine supported scan sources.");
throw;
}
// auto mode
if (IsAutoAllowed)
{
LogService.Log.Information("DiscoveredScanner: Processing auto mode");
IsAutoPreviewAllowed = device.IsPreviewSupported(ImageScannerScanSource.AutoConfigured);
AutoFormats = GenerateFormats(device.AutoConfiguration);
}
// flatbed mode
if (IsFlatbedAllowed)
{
LogService.Log.Information("DiscoveredScanner: Processing flatbed mode");
IsFlatbedColorAllowed = device.FlatbedConfiguration.IsColorModeSupported(ImageScannerColorMode.Color);
IsFlatbedGrayscaleAllowed = device.FlatbedConfiguration.IsColorModeSupported(ImageScannerColorMode.Grayscale);
IsFlatbedMonochromeAllowed = device.FlatbedConfiguration.IsColorModeSupported(ImageScannerColorMode.Monochrome);
IsFlatbedAutoColorAllowed = device.FlatbedConfiguration.IsColorModeSupported(ImageScannerColorMode.AutoColor);
if (!IsFlatbedColorAllowed && !IsFlatbedGrayscaleAllowed && !IsFlatbedMonochromeAllowed && !IsFlatbedAutoColorAllowed)
{
// no color mode allowed, source mode is invalid
IsFlatbedAllowed = false;
LogService.Log.Warning("DiscoveredScanner: No color mode for flatbed allowed, invalid source mode");
}
else
{
LogService.Log.Information("DiscoveredScanner: Flatbed supports at least one color mode");
try
{
IsFlatbedPreviewAllowed = device.IsPreviewSupported(ImageScannerScanSource.Flatbed);
}
catch (Exception exc)
{
LogService.Log.Error(exc, "DiscoveredScanner: Couldn't determine preview support for flatbed.");
throw;
}
try
{
IsFlatbedAutoCropSingleRegionAllowed = device.FlatbedConfiguration
.IsAutoCroppingModeSupported(ImageScannerAutoCroppingMode.SingleRegion);
IsFlatbedAutoCropMultiRegionAllowed = device.FlatbedConfiguration
.IsAutoCroppingModeSupported(ImageScannerAutoCroppingMode.MultipleRegion);
}
catch (Exception exc)
{
LogService.Log.Error(exc, "DiscoveredScanner: Couldn't determine auto crop support for flatbed.");
throw;
}
FlatbedResolutions = GenerateResolutions(device.FlatbedConfiguration);
LogService.Log.Information("Generated {@Resolutions} for flatbed.", FlatbedResolutions);
FlatbedFormats = GenerateFormats(device.FlatbedConfiguration);
LogService.Log.Information("Generated {@Formats} for feeder.", FlatbedFormats);
try
{
if (device.FlatbedConfiguration.BrightnessStep != 0)
{
FlatbedBrightnessConfig = GenerateBrightnessConfig(device.FlatbedConfiguration);
}
}
catch (Exception exc)
{
LogService.Log.Error(exc, "DiscoveredScanner: Couldn't determine BrightnessConfig for flatbed.");
throw;
}
try
{
if (device.FlatbedConfiguration.ContrastStep != 0)
{
FlatbedContrastConfig = GenerateContrastConfig(device.FlatbedConfiguration);
}
}
catch (Exception exc)
{
LogService.Log.Error(exc, "DiscoveredScanner: Couldn't determine ContrastConfig for flatbed.");
throw;
}
}
}
// feeder mode
if (IsFeederAllowed)
{
LogService.Log.Information("DiscoveredScanner: Processing feeder mode");
IsFeederColorAllowed = device.FeederConfiguration.IsColorModeSupported(ImageScannerColorMode.Color);
IsFeederGrayscaleAllowed = device.FeederConfiguration.IsColorModeSupported(ImageScannerColorMode.Grayscale);
IsFeederMonochromeAllowed = device.FeederConfiguration.IsColorModeSupported(ImageScannerColorMode.Monochrome);
IsFeederAutoColorAllowed = device.FeederConfiguration.IsColorModeSupported(ImageScannerColorMode.AutoColor);
if (!IsFeederColorAllowed && !IsFeederGrayscaleAllowed && !IsFeederMonochromeAllowed && !IsFeederAutoColorAllowed)
{
// no color mode allowed, source mode is invalid
IsFeederAllowed = false;
LogService.Log.Warning("DiscoveredScanner: No color mode for feeder allowed, invalid source mode");
}
else
{
LogService.Log.Information("DiscoveredScanner: Feeder supports at least one color mode");
try
{
IsFeederDuplexAllowed = device.FeederConfiguration.CanScanDuplex;
}
catch (Exception exc)
{
LogService.Log.Error(exc, "DiscoveredScanner: Couldn't determine duplex support for feeder.");
throw;
}
try
{
IsFeederPreviewAllowed = device.IsPreviewSupported(ImageScannerScanSource.Feeder);
}
catch (Exception exc)
{
LogService.Log.Error(exc, "DiscoveredScanner: Couldn't determine preview support for feeder.");
throw;
}
try
{
IsFeederAutoCropSingleRegionAllowed = device.FeederConfiguration
.IsAutoCroppingModeSupported(ImageScannerAutoCroppingMode.SingleRegion);
IsFeederAutoCropMultiRegionAllowed = device.FeederConfiguration
.IsAutoCroppingModeSupported(ImageScannerAutoCroppingMode.MultipleRegion);
}
catch (Exception exc)
{
LogService.Log.Error(exc, "DiscoveredScanner: Couldn't determine auto crop support for feeder.");
throw;
}
FeederResolutions = GenerateResolutions(device.FeederConfiguration);
LogService.Log.Information("Generated {@Resolutions} for feeder.", FeederResolutions);
FeederFormats = GenerateFormats(device.FeederConfiguration);
LogService.Log.Information("Generated {@Formats} for feeder.", FeederFormats);
try
{
if (device.FeederConfiguration.BrightnessStep != 0)
{
FeederBrightnessConfig = GenerateBrightnessConfig(device.FeederConfiguration);
}
}
catch (Exception exc)
{
LogService.Log.Error(exc, "DiscoveredScanner: Couldn't determine BrightnessConfig for feeder.");
throw;
}
try
{
if (device.FeederConfiguration.ContrastStep != 0)
{
FeederContrastConfig = GenerateContrastConfig(device.FeederConfiguration);
}
}
catch (Exception exc)
{
LogService.Log.Error(exc, "DiscoveredScanner: Couldn't determine ContrastConfig for feeder.");
throw;
}
}
}
if (!IsAutoAllowed && !IsFlatbedAllowed && !IsFeederAllowed)
{
// no source mode allowed, scanner is invalid and useless
throw new ArgumentException("Scanner doesn't support any source mode and can't be used.");
}
LogService.Log.Information("Created {@DiscoveredScanner}", this);
}
private static void ConfigureScanner(
ImageScanner scanner, ImageScannerScanSource source,
Double hScanPercent, Double vScanPercent)
{
if (scanner == null)
{
throw new ArgumentNullException("scanner");
}
IImageScannerSourceConfiguration sourceConfig = null;
IImageScannerFormatConfiguration formatConfig = null;
switch (source)
{
case ImageScannerScanSource.Flatbed:
sourceConfig = scanner.FlatbedConfiguration;
formatConfig = scanner.FlatbedConfiguration;
break;
case ImageScannerScanSource.Feeder:
sourceConfig = scanner.FeederConfiguration;
formatConfig = scanner.FeederConfiguration;
//Additional feeder-specific settings:
//scanner.FeederConfiguration.CanScanDuplex
//scanner.FeederConfiguration.Duplex
//scanner.FeederConfiguration.CanScanAhead
//scanner.FeederConfiguration.ScanAhead
//scanner.FeederConfiguration.AutoDetectPageSize
//scanner.FeederConfiguration.CanAutoDetectPageSize
//scanner.FeederConfiguration.PageSize
//scanner.FeederConfiguration.PageSizeDimensions
//scanner.FeederConfiguration.PageOrientation
break;
case ImageScannerScanSource.AutoConfigured:
formatConfig = scanner.AutoConfiguration;
break;
}
// Potentially update the scanner configuration
if (sourceConfig != null)
{
var maxScanArea = sourceConfig.MaxScanArea; // Size, with Width, Height in Inches // MinScanArea
sourceConfig.SelectedScanRegion = new Rect(
0,
0,
maxScanArea.Width * hScanPercent,
maxScanArea.Height * vScanPercent); // In inches
// Additional Configuration settings
// sourceConfig.AutoCroppingMode
// sourceConfig.ColorMode == // DefaultColorMode
// sourceConfig.Brightness // DefaultBrightness //MaxBrightness // MinBrightness
// sourceConfig.Contrast // DefaultContrast // MaxContrast // MinContrast
// sourceConfig.DesiredResolution = resolution; // MaxResolution // MinResolution
// var actualResolution = sourceConfig.ActualResolution;
}
// Potentially update the format that the end product is saved to
if (formatConfig != null)
{
Debug.WriteLine("Default format is {0}", formatConfig.DefaultFormat);
// NOTE: If your desired format isn't natively supported, it may
// be possible to generate the desired format post-process
// using image conversion, etc. libraries.
var desiredFormats = new[]
{
ImageScannerFormat.Png,
ImageScannerFormat.Jpeg,
ImageScannerFormat.DeviceIndependentBitmap,
//ImageScannerFormat.Tiff,
//ImageScannerFormat.Xps,
//ImageScannerFormat.OpenXps,
//ImageScannerFormat.Pdf
};
foreach (var format in desiredFormats)
{
if (formatConfig.IsFormatSupported(format))
{
formatConfig.Format = format;
break;
}
}
Debug.WriteLine("Configured format is {0}", formatConfig.Format);
}
}
/// <summary>
/// Scans all the images from Feeder source of the scanner
/// The scanning of the image is allowed only if the selected scanner has Feeder source
/// </summary>
/// <param name="deviceId">scanner device id</param>
/// <param name="folder">the folder that receives the scanned files</param>
public async void ScanToFolder(string deviceId, StorageFolder folder)
{
try
{
// Get the scanner object for this device id
ImageScanner myScanner = await ImageScanner.FromIdAsync(deviceId);
// Check to see if the use has already cancelled the scenario
if (ModelDataContext.ScenarioRunning)
{
if (myScanner.IsScanSourceSupported(ImageScannerScanSource.Feeder))
{
// Update Feeder Configuration
// Set the scan file format to PNG, if available, if not to DIB
if (myScanner.FeederConfiguration.IsFormatSupported(ImageScannerFormat.Png))
{
myScanner.FeederConfiguration.Format = ImageScannerFormat.Png;
}
else
{
myScanner.FeederConfiguration.Format = ImageScannerFormat.DeviceIndependentBitmap;
}
// Set the color mode to Grayscale, if available
if (myScanner.FeederConfiguration.IsColorModeSupported(ImageScannerColorMode.Grayscale))
{
myScanner.FeederConfiguration.ColorMode = ImageScannerColorMode.Grayscale;
}
// Set feeder to scan duplex
myScanner.FeederConfiguration.Duplex = myScanner.FeederConfiguration.CanScanDuplex;
// Set MaxNumberOfPages to zero to scanning all the pages that are present in the feeder
myScanner.FeederConfiguration.MaxNumberOfPages = 0;
rootPage.NotifyUser("Scanning", NotifyType.StatusMessage);
var progress = new Progress <UInt32>(ScanProgress);
cancellationToken = new CancellationTokenSource();
// Scan API call to start scanning from the Feeder source of the scanner.
var result = await myScanner.ScanFilesToFolderAsync(ImageScannerScanSource.Feeder, folder).AsTask(cancellationToken.Token, progress);
ModelDataContext.ScenarioRunning = false;
if (result.ScannedFiles.Count > 0)
{
Utils.DisplayImageAndScanCompleteMessage(result.ScannedFiles, DisplayImage);
if (result.ScannedFiles.Count > 1)
{
Utils.UpdateFileListData(result.ScannedFiles, ModelDataContext);
}
}
else
{
rootPage.NotifyUser("There are no files scanned from the Feeder.", NotifyType.ErrorMessage);
}
}
else
{
ModelDataContext.ScenarioRunning = false;
rootPage.NotifyUser("The selected scanner does not report to be equipped with a Feeder.", NotifyType.ErrorMessage);
}
}
}
catch (OperationCanceledException)
{
Utils.DisplayScanCancelationMessage();
}
catch (Exception ex)
{
Utils.OnScenarioException(ex, ModelDataContext);
}
}
