private bool SetDocumentLoadResultion(RasterCodecs codecs, CodecsImageInfo info, int firstPage, int lastPage)
{
if (!Is64) // No limit for x64
{
if (info.Document.IsDocumentFile) // if the file is a document file format
{
if (firstPage < 1)
{
firstPage = 1;
}
if ((((lastPage == -1) && (info.TotalPages > maxDocPages)) || (lastPage - firstPage + 1 > maxDocPages)) && ((codecs.Options.RasterizeDocument.Load.XResolution > maxDocResolution) || (codecs.Options.RasterizeDocument.Load.YResolution > maxDocResolution)))
{
string promptMessage = string.Format("You are trying to load a document file which has more than {0} pages at {1} dpi.{2}{2}", maxDocPages, codecs.Options.RasterizeDocument.Load.XResolution, Environment.NewLine);
promptMessage = string.Format("{0}This can cause performance issues on machines with limited resources.{1}{1}", promptMessage, Environment.NewLine);
promptMessage = string.Format("{0}Click 'Yes' to reduce the resolution and continue loading or click 'No' to continue loading with the current resolution.", promptMessage);
DialogResult result = MessageBox.Show(promptMessage, "Warning", MessageBoxButtons.YesNoCancel);
switch (result)
{
case DialogResult.Yes:
codecs.Options.RasterizeDocument.Load.XResolution = 96;
codecs.Options.RasterizeDocument.Load.YResolution = 96;
break;
case DialogResult.No:
break;
case DialogResult.Cancel:
return(false);
}
}
}
}
return(true);
}
private void LoadFile(RasterCodecs codec)
{
if (fileName == null || "".Equals(fileName))
{
_image = null;
return;
}
CodecsTiffLoadOptions options = codec.Options.Tiff.Load;
/*
* codec.Options.Load.Compressed = true;
*/
// codec.Options.Load.XResolution = 204;
// codec.Options.Load.YResolution = 196;
//
CodecsImageInfo info = codec.GetInformation(fileName, true);
int firstPage = 1;
int lastPage = info.TotalPages;
_image = codec.Load(fileName, 0, CodecsLoadByteOrder.BgrOrGray, firstPage, lastPage);
//codec.Options.Load.
}
private void LoadImage(bool loadDefaultImage)
{
RasterOpenDialogLoadFormat[] loaderFilters = new RasterOpenDialogLoadFormat[3];
loaderFilters[0] = new RasterOpenDialogLoadFormat("Bitmap Files (*.dib;*.bmp)", "*.dib;*.bmp");
loaderFilters[1] = new RasterOpenDialogLoadFormat("TIFF Files (*.tif)", "*.tif");
loaderFilters[2] = new RasterOpenDialogLoadFormat("All Files (*.tif, *.bmp)", "*.tif;*.bmp");
ImageFileLoader loader = new ImageFileLoader();
loader.OpenDialogInitialPath = _openInitialPath;
loader.Filters = loaderFilters;
bool bLoaded = false;
try
{
if (loadDefaultImage)
{
bLoaded = loader.Load(this, DemosGlobal.ImagesFolder + @"\ET\dst_rgb_image.tif", _codecs, 1, 1);
}
else
{
bLoaded = loader.Load(this, _codecs, true) > 0;
}
if (bLoaded)
{
_openInitialPath = Path.GetDirectoryName(loader.FileName);
// Resize the image so each dimension becomes a multiple of 4. This is done because it's required by some color spaces
int width = loader.Image.Width;
int height = loader.Image.Height;
width += (width % 4 == 0) ? 0 : (4 - (width % 4));
height += (height % 4 == 0) ? 0 : (4 - (height % 4));
// If the width and the height were the same, the SizeCommand will return immediately.
SizeCommand sizeCommand = new SizeCommand(width, height, RasterSizeFlags.None);
sizeCommand.Run(loader.Image);
CodecsImageInfo info = _codecs.GetInformation(loader.FileName, false, 1);
if (info.BitsPerPixel == 24)
{
_viewer.Image = loader.Image;
Text = "LEADTOOLS for .NET C# Color Conversion Demo";
}
else
{
Messager.ShowError(this, "Format not supported\nthis demo supports simple TIFF - (RGB24, CMYK, YCC and LAB) and BMP - (RGB24)");
}
}
}
catch (Exception ex)
{
Messager.ShowError(this, ex);
}
finally
{
UpdateMyControls();
}
}
private void LoadImageList()
{
if (fileName == null || "".Equals(fileName))
{
return;
}
if (!File.Exists(fileName))
{
throw new FileNotFoundException();
}
RasterCodecs codec = new RasterCodecs();
CodecsImageInfo info = codec.GetInformation(fileName, true);
RasterPaintProperties paintProp = imageList.PaintProperties;
paintProp.PaintDisplayMode = RasterPaintDisplayModeFlags.ScaleToGray;
int lastPage = info.TotalPages;
image = codec.Load(fileName, 0, CodecsLoadByteOrder.BgrOrGray, 1, lastPage);
imageList.Items.Clear();
int totalCount = image.PageCount;
for (int i = 1; i <= totalCount; ++i)
{
RasterImageListItem imageItem = new RasterImageListItem(image, i, "Page " + i.ToString());
imageList.Items.Add(imageItem);
}
LoadCheckBox(totalCount);
}
private void LoadStream(RasterCodecs codec)
{
if (stream == null)
{
_image = null;
return;
}
CodecsTiffLoadOptions options = codec.Options.Tiff.Load;
/*
* codec.Options.Load.Compressed = true;
*/
// codec.Options.Load.XResolution = 204;
// codec.Options.Load.YResolution = 196;
//
CodecsImageInfo info = codec.GetInformation(stream, true);
int firstPage = 1;
int lastPage = info.TotalPages;
_image = codec.Load(stream, 0, CodecsLoadByteOrder.BgrOrGray, firstPage, lastPage);
}
private void LoadImage(bool loadDefaultImage)
{
try
{
ImageFileLoader loader = new ImageFileLoader();
bool bLoaded = false;
if (loadDefaultImage)
{
bLoaded = loader.Load(this, DemosGlobal.ImagesFolder + @"\image1.j2k", _codecs, 1, 1);
}
else
{
ImageFileLoader.FilterIndex = 5;
bLoaded = loader.Load(this, _codecs, true) > 0;
}
if (bLoaded)
{
// Load and set the new image in the viewer
_viewer.Image = loader.Image;
// Get the information about the image
CodecsImageInfo imageInformation = _codecs.GetInformation(loader.FileName, false);
switch (imageInformation.Format)
{
case RasterImageFormat.J2k:
case RasterImageFormat.Jp2:
case RasterImageFormat.Cmw:
{
this.Text = String.Format("LEADTOOLS for .NET C# JPEG 2000 Demo {0} X {1}", _viewer.Image.Width, _viewer.Image.Height);
break;
}
default:
{
this.Text = string.Format("{0} - {1}", loader.FileName, Messager.Caption);
break;
}
}
_fileName = loader.FileName;
_originalWidth = imageInformation.Width;
_originalHeight = imageInformation.Height;
_viewer.Invalidate(true);
}
}
catch (Exception ex)
{
Messager.ShowError(this, ex);
}
finally
{
UpdateMyControls();
}
}
public HttpResponseMessage CreateFiles(FormDataCollection Form)
{
HttpResponseMessage httpResponseMessage = Request.CreateResponse(HttpStatusCode.OK, "Some problem in create master form set.");
try
{
if (Form != null)
{
string FileName = Form["FileName"]?.ToString().Trim() ?? "";
string folderName = Form["FolderName"]?.ToString().Trim() ?? "";
string FriendlyName = Form["FriendlyName"]?.ToString().Trim() ?? "";
string workingDirectory = HttpContext.Current.Server.MapPath("~/" + RootFolderName + "/" + FriendlyName);
string tempDirectory = HttpContext.Current.Server.MapPath("~/" + RootFolderName + "/temp");
string filePath = tempDirectory + @"\" + FileName;
if (Directory.Exists(workingDirectory) && Directory.Exists(tempDirectory) && File.Exists(filePath))
{
ServiceHelper.SetLicense();
RasterImage scannedImage = null;
using (RasterCodecs _codecs = new RasterCodecs())
{
//scannedImage = _codecs.Load(filePath);
CodecsImageInfo info = _codecs.GetInformation(filePath, true);
int infoTotalPages = info.TotalPages;
scannedImage = _codecs.Load(filePath, 0, CodecsLoadByteOrder.BgrOrGray, 1, info.TotalPages);
DirectoryInfo directoryInfo = new DirectoryInfo(workingDirectory);
if (directoryInfo.GetFiles("*").ToList().Count == 0)
{
CreateMasterForms(scannedImage, workingDirectory, FriendlyName, folderName);
File.Delete(filePath);
httpResponseMessage = Request.CreateResponse(HttpStatusCode.OK, "Master form created successfully.");
}
else
{
workingRepository = new DiskMasterFormsRepository(_codecs, workingDirectory);
var diskMasterForm = workingRepository?.RootCategory?.MasterForms?.FirstOrDefault();
if (diskMasterForm != null)
{
AddMasterFormPages(scannedImage, (DiskMasterForm)diskMasterForm, folderName);
}
File.Delete(filePath);
httpResponseMessage = Request.CreateResponse(HttpStatusCode.OK, "Page added to master form set successfully.");
}
}
}
}
}
catch (Exception ex)
{
httpResponseMessage = Request.CreateResponse(HttpStatusCode.OK, "Some problem in create master form set." + ex.Message.ToString());
}
return(httpResponseMessage);
}
private void InitializeFromStream(Stream stream)
{
codec = new RasterCodecs();
codec.Options.Txt.Load.Enabled = true;
CodecsImageInfo info = codec.GetInformation(stream, true);
int lastPage = info.TotalPages;
ImageData = codec.Load(stream, 0, CodecsLoadByteOrder.BgrOrGray, 1, lastPage);
codec.Options.Load.XResolution = ImageData.XResolution;
codec.Options.Load.YResolution = ImageData.YResolution;
LoadTagsMetaData(stream);
}
/// <summary>
/// Zoom the image
/// </summary>
private void _miZoom_Click(object sender, System.EventArgs e)
{
double scaleFactor = _viewer.ScaleFactor;
if (sender == _miZoomIn)
{
if (_originalWidth > _viewer.Image.Width && (scaleFactor == 1))
{
using (RasterCodecs codecs = new RasterCodecs())
{
CodecsImageInfo _imageInformation = codecs.GetInformation(_fileName, false);
switch (_imageInformation.Format)
{
case RasterImageFormat.J2k:
codecs.Options.Jpeg2000.Load.J2kResolution = new LeadSize(_viewer.Image.Width * 2, _viewer.Image.Height * 2);
break;
case RasterImageFormat.Jp2:
codecs.Options.Jpeg2000.Load.Jp2Resolution = new LeadSize(_viewer.Image.Width * 2, _viewer.Image.Height * 2);
break;
case RasterImageFormat.Cmw:
codecs.Options.Jpeg2000.Load.CmwResolution = new LeadSize(_viewer.Image.Width * 2, _viewer.Image.Height * 2);
break;
}
_viewer.Cursor = Cursors.WaitCursor;
_viewer.Image.Dispose();
_viewer.Image = codecs.Load(_fileName);
this.Text = String.Format("LEADTOOLS for .NET C# JPEG 2000 Demo {0} X {1}", _viewer.Image.Width, _viewer.Image.Height);
_viewer.Cursor = Cursors.Arrow;
}
}
else
{
scaleFactor *= 2;
}
}
else if (sender == _miZoomOut)
{
scaleFactor /= 2;
}
else if (sender == _miZoomNormal)
{
scaleFactor = 1;
_viewer.Zoom(ControlSizeMode.None, scaleFactor, _viewer.DefaultZoomOrigin);
}
if ((scaleFactor > 0.009) && (scaleFactor < 11))
{
_viewer.Zoom(ControlSizeMode.None, scaleFactor, _viewer.DefaultZoomOrigin);
}
}
public void InitDialog(string fileName, RasterCodecs codecs)
{
_lstAttachments.View = View.Details;
_fileName = fileName;
_codecs = codecs;
foreach (AttachmentColumnHeader columnHeader in _attachmentColumnHeaders)
{
_lstAttachments.Columns.Add(columnHeader._columnName, columnHeader._columnWidth, HorizontalAlignment.Left);
}
CodecsAttachments attachments = codecs.ReadAttachments(fileName);
int attachmentNumber = 0;
foreach (CodecsAttachment attachment in attachments)
{
attachmentNumber++;
double fileSize = attachment.FileLength / 1024.0;
string tempPath = Path.GetTempPath();
string tempAttachmentFile = Path.Combine(Path.GetTempPath(), string.Format("LT_CS_{0}.tmp", attachment.FileName));
ExtractAttachmentFile(tempAttachmentFile, attachmentNumber);
CodecsImageInfo info = null;
try
{
info = codecs.GetInformation(tempAttachmentFile, true);
}
catch { }
ListViewItem item = new ListViewItem(new[] { attachment.DisplayName, (info != null) ? ((info.AttachmentCount > 0) ? "Yes" : "No") : "No", attachment.TimeModified.ToString(), (info != null) ? info.IsPortfolio.ToString() : "No", fileSize.ToString("N") + " KB", attachment.Description });
_lstAttachments.Items.Add(item);
if (File.Exists(tempAttachmentFile))
{
File.Delete(tempAttachmentFile);
}
if (info != null)
{
info.Dispose();
}
}
}
//Use this load to load a specific image without showing the open dialog
public bool Load(IWin32Window owner, string fileName, RasterCodecs codecs, int firstPage, int lastPage)
{
_fileName = fileName;
_firstPage = firstPage;
_lastPage = lastPage;
using (WaitCursor wait = new WaitCursor())
{
using (CodecsImageInfo info = codecs.GetInformation(FileName, true))
{
if (!SetDocumentLoadResultion(codecs, info, firstPage, lastPage))
{
return(false);
}
}
_image = codecs.Load(FileName, 0, CodecsLoadByteOrder.BgrOrGray, _firstPage, _lastPage);
}
return(true);
}
static MedicalViewerPageInfo[] GetPagesPresentationInfo(DicomDataSet ds, MedicalViewerPageInfo ppiMaster, int DefTotalPages)
{
int nFrames = DefTotalPages;
DicomElement elemNumberOfFrames = ds.FindFirstElement(null, DicomTag.NumberOfFrames, true);
string path = ExtractPDFData(ds);
if (!string.IsNullOrEmpty(path))
{
using (RasterCodecs codecs = new RasterCodecs())
{
using (CodecsImageInfo info = codecs.GetInformation(path, true))
{
nFrames = info.TotalPages;
}
}
}
else
if (null != elemNumberOfFrames)
{
int[] nFramesList = ds.GetIntValue(elemNumberOfFrames, 0, 1);
nFrames = Math.Max(nFrames, nFramesList[0]);
}
List <MedicalViewerPageInfo> PagePresentationInfoLstFromDS = GetPagesInfoFromMaster(ds, ppiMaster);
List <MedicalViewerPageInfo> PagePresentationInfoLst = new List <MedicalViewerPageInfo>();
for (int nIndex = 0; nIndex < nFrames; nIndex++)
{
if (nIndex < PagePresentationInfoLstFromDS.Count)
{
PagePresentationInfoLst.Add(PagePresentationInfoLstFromDS[nIndex]);
}
else
{
PagePresentationInfoLst.Add(null);
}
}
return(PagePresentationInfoLst.ToArray());
}
private bool IsImageValid(CodecsImageInfo imageInfo)
{
bool imageValid = false;
switch (imageInfo.BitsPerPixel)
{
case 32:
case 24:
case 16:
case 12:
case 8:
imageValid = true;
break;
default:
imageValid = false;
break;
}
return(imageValid && imageInfo.ViewPerspective == RasterViewPerspective.TopLeft);
}
public ImageDocumentViewModel(Stream stream)
{
RasterCodecs codecs = new RasterCodecs();
codecs.Options.Load.PreferVector = true;
codecs.Options.Load.AllPages = true;
codecs.Options.Load.Resolution = 72;
codecs.StartOptimizedLoad();
CodecsImageInfo imageInfo = codecs.GetInformation(stream, true);
Pages = new ObservableCollection <PageViewModel>();
for (int page = 1; page <= imageInfo.TotalPages; page++)
{
Pages.Add(new PageViewModel(stream, codecs, page));
}
if (imageInfo.TotalPages > 0)
{
SetActivePage(1);
}
}
public void InitDialog(string fileName, CodecsImageInfo codecs)
{
_lstInfo.Columns.Add("Item", 100, HorizontalAlignment.Left);
_lstInfo.Columns.Add("Value", 100, HorizontalAlignment.Left);
ListViewItem item = new ListViewItem(new[] { "Format", codecs.Format.ToString() });
_lstInfo.Items.Add(item);
item = new ListViewItem(new[] { "Name", fileName });
_lstInfo.Items.Add(item);
item = new ListViewItem(new[] { "Width", codecs.Width.ToString() });
_lstInfo.Items.Add(item);
item = new ListViewItem(new[] { "Height", codecs.Height.ToString() });
_lstInfo.Items.Add(item);
item = new ListViewItem(new[] { "Bits Per Pixel", codecs.BitsPerPixel.ToString() });
_lstInfo.Items.Add(item);
item = new ListViewItem(new[] { "Compression", codecs.Compression });
_lstInfo.Items.Add(item);
item = new ListViewItem(new[] { "Total Pages", codecs.TotalPages.ToString() });
_lstInfo.Items.Add(item);
item = new ListViewItem(new[] { "XResolution(DPI)", codecs.XResolution.ToString() });
_lstInfo.Items.Add(item);
item = new ListViewItem(new[] { "YResolution(DPI)", codecs.YResolution.ToString() });
_lstInfo.Items.Add(item);
item = new ListViewItem(new[] { "Is Portfolio", codecs.IsPortfolio.ToString() });
_lstInfo.Items.Add(item);
item = new ListViewItem(new[] { "Attachments Count", codecs.AttachmentCount.ToString() });
_lstInfo.Items.Add(item);
}
private bool GetDocumentInformation()
{
// Get all the options
if (!CollectAllOptions())
{
return(false);
}
// Get the new image information
string documentPath = _documentPathControl.DocumentPath;
try
{
CodecsImageInfo newImageInfo = null;
using (WaitCursor wait = new WaitCursor())
{
newImageInfo = _rasterCodecsInstance.GetInformation(documentPath, false);
}
// Use this information
if (_imageInfo != null)
{
_imageInfo.Dispose();
}
_imageInfo = newImageInfo;
_documentInfoControl.SetData(_imageInfo, _rasterCodecsInstance);
return(true);
}
catch (Exception ex)
{
Messager.ShowError(this, ex);
return(false);
}
}
private void _btnInfo_Click(object sender, EventArgs e)
{
if (_lstAttachments.SelectedItems.Count > 0)
{
int selectedIndex = _lstAttachments.SelectedIndices[0];
AttachmentInfoDialog attachmentInfoDlg = new AttachmentInfoDialog();
string attachmentFileName = _lstAttachments.Items[selectedIndex].Text;
string tempPath = Path.GetTempPath();
string tempAttachmentFile = Path.Combine(Path.GetTempPath(), string.Format("LT_CS_{0}.tmp", attachmentFileName));
ExtractAttachmentFile(tempAttachmentFile, selectedIndex + 1);
try
{
using (CodecsImageInfo info = _codecs.GetInformation(tempAttachmentFile, true))
{
attachmentInfoDlg.InitDialog(attachmentFileName, info);
attachmentInfoDlg.ShowDialog(this);
}
}
catch (Exception ex)
{
Messager.ShowError(this, ex);
}
if (File.Exists(tempAttachmentFile))
{
File.Delete(tempAttachmentFile);
}
}
else
{
Messager.ShowWarning(this, "No selected attachment!");
}
}
public ImageInfo Info(Uri uri, int pageNumber = 1)
{
if (uri == null)
{
throw new ArgumentNullException("uri");
}
if (pageNumber < 0)
{
throw new ArgumentOutOfRangeException("pageNumber", "must be a value greater than or equal to 0");
}
var page = pageNumber;
// Default is page 1
if (page == 0)
{
page = 1;
}
// Use a temp file, much faster than calling Load/Info from a URI directly
// In a production service, you might want to create a caching mechanism
string tempFile = Path.GetTempFileName();
try
{
// Force the uri to be fully qualified, reject everything else for security reasons
if (uri.IsFile || uri.IsUnc)
{
throw new ArgumentException("URL cannot be local file or UNC path.");
}
// Download the file
if (File.Exists(HttpContext.Current.Server.MapPath("~/" + uri.LocalPath.ToString())))
{
using (WebClient client = new WebClient())
client.DownloadFile(uri, tempFile);
}
else
{
ImageInfo imginfo = new ImageInfo();
return(imginfo);
//throw new FileNotFoundException("Master set detail does not exists.");
}
using (RasterCodecs codecs = new RasterCodecs())
{
// Initialize the options for RasterCodecs
ServiceHelper.InitCodecs(codecs, 0);
using (CodecsImageInfo info = codecs.GetInformation(tempFile, true, page))
{
ImageInfo imageInfo = new ImageInfo();
imageInfo.Uri = uri.ToString();
imageInfo.FormatId = (int)info.Format;
imageInfo.FormatName = info.Format.ToString();
imageInfo.MimeType = RasterCodecs.GetMimeType(info.Format);
imageInfo.Width = info.Width;
imageInfo.Height = info.Height;
imageInfo.BitsPerPixel = info.BitsPerPixel;
imageInfo.BytesPerLine = info.BytesPerLine;
imageInfo.SizeDisk = info.SizeDisk;
imageInfo.SizeMemory = info.SizeMemory;
imageInfo.Compression = info.Compression;
imageInfo.ViewPerspective = GetViewPerspectiveName(info.ViewPerspective);
imageInfo.Order = info.Order.ToString();
imageInfo.ColorSpace = info.ColorSpace.ToString();
imageInfo.PageNumber = info.PageNumber;
imageInfo.TotalPages = info.TotalPages;
imageInfo.HasResolution = info.HasResolution;
imageInfo.XResolution = info.XResolution;
imageInfo.YResolution = info.YResolution;
imageInfo.IsRotated = info.IsRotated;
imageInfo.IsSigned = info.IsSigned;
imageInfo.HasAlpha = info.HasAlpha;
imageInfo.BrowserCompatible = false;
switch (info.Format)
{
case RasterImageFormat.Png:
case RasterImageFormat.Gif:
case RasterImageFormat.Jpeg:
case RasterImageFormat.Jpeg411:
case RasterImageFormat.Jpeg422:
case RasterImageFormat.JpegLab:
case RasterImageFormat.JpegLab411:
case RasterImageFormat.JpegLab422:
case RasterImageFormat.JpegRgb:
imageInfo.BrowserCompatible = true;
break;
default:
break;
}
return(imageInfo);
}
}
}
catch (Exception ex)
{
Log(string.Format("Info - Error:{1}{0}TempFile:{2}{0}Uri:{3}, PageNumber:{4}", Environment.NewLine, ex.Message, tempFile, uri, page));
throw;
}
finally
{
if (File.Exists(tempFile))
{
try
{
File.Delete(tempFile);
}
catch { }
}
}
}
private void LoadDocument(string fileName, bool loadDefault)
{
try
{
using (RasterCodecs codecs = new RasterCodecs())
{
// Set load resolution
codecs.Options.RasterizeDocument.Load.XResolution = 300;
codecs.Options.RasterizeDocument.Load.YResolution = 300;
int firstPage = 1;
int lastPage = 1;
List <SvgDocument> documents = new List <SvgDocument>();
if (!loadDefault)
{
// Check if the file can be loaded as svg
bool canLoadSvg = codecs.CanLoadSvg(fileName);
using (CodecsImageInfo info = codecs.GetInformation(fileName, true))
{
if (!canLoadSvg)
{
// Check if the file type is not PDF
if (info.Format != RasterImageFormat.PdfLeadMrc &&
info.Format != RasterImageFormat.RasPdf &&
info.Format != RasterImageFormat.RasPdfCmyk &&
info.Format != RasterImageFormat.RasPdfG31Dim &&
info.Format != RasterImageFormat.RasPdfG32Dim &&
info.Format != RasterImageFormat.RasPdfG4 &&
info.Format != RasterImageFormat.RasPdfJbig2 &&
info.Format != RasterImageFormat.RasPdfJpeg &&
info.Format != RasterImageFormat.RasPdfJpeg411 &&
info.Format != RasterImageFormat.RasPdfJpeg422 &&
info.Format != RasterImageFormat.RasPdfJpx &&
info.Format != RasterImageFormat.RasPdfLzw &&
info.Format != RasterImageFormat.RasPdfLzwCmyk)
{
MessageBox.Show("The selected file can't be loaded as an SVG file", "Invalid File Format", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
if (info.TotalPages > 1)
{
using (ImageFileLoaderPagesDialog dlg = new ImageFileLoaderPagesDialog(info.TotalPages, false))
{
if (dlg.ShowDialog(this) == DialogResult.Cancel)
{
return;
}
firstPage = dlg.FirstPage;
lastPage = dlg.LastPage;
}
}
}
}
using (WaitCursor wait = new WaitCursor())
{
for (int page = firstPage; page <= lastPage; page++)
{
SvgDocument svgDoc = codecs.LoadSvg(fileName, page, _loadSvgOptions) as SvgDocument;
documents.Add(svgDoc);
}
SetDocument(fileName, documents, firstPage);
}
UpdateControls();
}
}
catch (Exception ex)
{
MessageBox.Show(this, string.Format("Error {0}{1}{2}", ex.GetType().FullName, Environment.NewLine, ex.Message), "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
private void ThreadProc(object stateInfo)
{
WorkItemData data = (WorkItemData)stateInfo;
IOcrEngine ocrEngine = null;
bool passedCriticalStage = false;
try
{
// See if we have canceled
lock (_abortedLockObject)
{
if (_aborted)
{
return;
}
}
string destinationFile = Path.Combine(data.DestinationDirectory, Path.GetFileName(data.SourceFile));
ocrEngine = data.OcrEngine;
lock (_abortedLockObject)
{
if (_aborted)
{
return;
}
}
// Convert this image file to a document
string extension = DocumentWriter.GetFormatFileExtension(data.Format);
destinationFile = string.Concat(destinationFile, ".", extension);
if (data.Format == DocumentFormat.Ltd && File.Exists(destinationFile))
{
File.Delete(destinationFile);
}
string sourceFile = Path.GetFileName(data.SourceFile);
try
{
// Create a document and add the pages
using (IOcrDocument ocrDocument = ocrEngine.DocumentManager.CreateDocument(null, OcrCreateDocumentOptions.AutoDeleteFile))
{
// Get the image number of pages
int imagePageCount;
RasterCodecs codecs = ocrDocument.RasterCodecsInstance;
using (CodecsImageInfo imageInfo = codecs.GetInformation(data.SourceFile, true))
{
long maximumMemorySize = 42187;
IOcrSettingManager settingManager = ocrEngine.SettingManager;
// Get the maximum size of the bitmap from the setting
if (settingManager.IsSettingNameSupported("Recognition.MaximumPageConventionalMemorySize"))
{
int maximumConventionalMemorySize = settingManager.GetIntegerValue("Recognition.MaximumPageConventionalMemorySize");
maximumMemorySize = (long)maximumConventionalMemorySize * 1024;
}
SetRecommendedLoadingOptions(codecs, imageInfo, maximumMemorySize);
imagePageCount = imageInfo.TotalPages;
}
// Set the DocumentWriter options
using (MemoryStream ms = new MemoryStream(data.DocumentWriterOptions))
{
ocrDocument.DocumentWriterInstance.LoadOptions(ms);
}
passedCriticalStage = true;
//recognize and add pages
for (int pageNumber = 1; pageNumber <= imagePageCount; pageNumber++)
{
lock (_abortedLockObject)
{
if (_aborted)
{
return;
}
}
var image = codecs.Load(data.SourceFile, pageNumber);
using (var ocrPage = ocrEngine.CreatePage(image, OcrImageSharingMode.AutoDispose))
{
ocrPage.Recognize(null);
ocrDocument.Pages.Add(ocrPage);
}
}
// Save
ocrDocument.Save(destinationFile, data.Format, null);
}
}
finally
{
}
OnSuccess(destinationFile);
}
catch (Exception ex)
{
string message;
if (passedCriticalStage && data.FirstTry)
{
message = string.Format("Error '{0}' while converting file '{1}' (first time, quarantined)", ex.Message, data.SourceFile);
AddToQuarantine(data.SourceFile);
}
else if (passedCriticalStage && !data.FirstTry)
{
message = string.Format("Error '{0}' while converting file '{1}' (quarantined error)", ex.Message, data.SourceFile);
}
else
{
message = string.Format("Error '{0}' while converting file '{1}'", ex.Message, data.SourceFile);
}
OnError(message);
}
finally
{
if (ocrEngine != null && ocrEngine != data.OcrEngine)
{
ocrEngine.Dispose();
}
if (Interlocked.Decrement(ref _workItemCount) == 0)
{
_batchFinishedEvent.Set();
}
}
}
private void _mnuFileSave_Click(object sender, EventArgs e)
{
if (_lstImagesInfoMulti == null || _lstImagesInfoMulti.Count <= 0)
{
Messager.ShowError(this, "Please Load Files");
return;
}
RasterImage img = null;
Cursor cursor = this.Cursor;
try
{
cursor = this.Cursor;
this.Cursor = Cursors.WaitCursor;
EnableControls(false);
this._labelConverted.Text = "0";
if (_saveDialog.ShowDialog() == DialogResult.OK)
{
RasterImageFormat selectedformat = RasterImageFormat.CcittGroup4;
if (_saveDialog.FilterIndex == 2)
{
selectedformat = RasterImageFormat.RasPdfG4;
}
_szMultiPageFile = _saveDialog.FileName;
if (_mnuOptionsSingleRasterImage.Checked)
{
for (int i = 0; i < _lstImagesInfoMulti.Count; i++)
{
RasterImage loadedImage = _codecs.Load(_lstImagesInfoMulti[i].Name, 0, CodecsLoadByteOrder.BgrOrGrayOrRomm, 1, -1);
if (i == 0)
{
img = loadedImage;
}
else
{
img.AddPages(loadedImage, 1, -1);
}
_labelConverted.Text = (Convert.ToInt32(_labelConverted.Text) + 1).ToString();
Application.DoEvents();
}
_codecs.Save(img, _szMultiPageFile, selectedformat, 0);
img.Dispose();
}
else
{
for (int i = 0; i < _lstImagesInfoMulti.Count; i++)
{
CodecsImageInfo info = _codecs.GetInformation(_lstImagesInfoMulti[i].Name, true);
for (int j = 1; j <= info.TotalPages; j++)
{
img = _codecs.Load(_lstImagesInfoMulti[i].Name, 0, CodecsLoadByteOrder.BgrOrGrayOrRomm, j, j);
if (i == 0 && j == 1)
{
_codecs.Save(img, _szMultiPageFile, selectedformat, 0, 1, 1, 1, CodecsSavePageMode.Overwrite);
}
else
{
while (!ReadyToAccess(_szMultiPageFile))//Insure File is not inused by other processes
{
Application.DoEvents();
}
_codecs.Save(img, _szMultiPageFile, selectedformat, 0, 1, 1, -1, CodecsSavePageMode.Append);
}
img.Dispose();
Application.DoEvents();
}
_labelConverted.Text = (Convert.ToInt32(_labelConverted.Text) + 1).ToString();
info.Dispose();
Application.DoEvents();
}
}
Messager.ShowInformation(this, "Save in MultiPageFile Done");
}
}
catch (Exception ex)
{
Messager.ShowError(this, ex);
}
finally
{
this.Cursor = cursor;
EnableControls(true);
}
}
private string DoTheConvert(string sourceImage, string actionProfile, string annotate, ReturnPath retPath)
{
string strRetFile = "";
strActionProfile = actionProfile;
strAnnotate = annotate;
this.sourceImage = sourceImage;
try
{
RasterCodecs.Startup();
RasterSupport.Unlock(RasterSupportType.Pro, "LhwcFdF3jN");
bool isLocked = RasterSupport.IsLocked(RasterSupportType.Pro);
rasterCodecs = new RasterCodecs();
imageInfo = rasterCodecs.GetInformation(sourceImage, true);
if (imageInfo.TotalPages > 0 && imageInfo.Format == Leadtools.RasterImageFormat.Gif)
{
rasterCodecs.Options.Gif.Load.AnimationLoop = imageInfo.Gif.AnimationLoop;
rasterCodecs.Options.Gif.Save.AnimationLoop = imageInfo.Gif.AnimationLoop;
rasterCodecs.Options.Gif.Save.UseAnimationLoop = imageInfo.Gif.HasAnimationLoop;
if (imageInfo.Gif.HasAnimationBackground)
{
rasterCodecs.Options.Gif.Save.AnimationBackground = imageInfo.Gif.AnimationBackground;
}
rasterCodecs.Options.Gif.Save.UseAnimationBackground = imageInfo.Gif.HasAnimationBackground;
// #1.0.5.0
if (imageInfo.Gif.HasAnimationPalette)
{
rasterCodecs.Options.Gif.Save.SetAnimationPalette(imageInfo.Gif.GetAnimationPalette());
}
rasterCodecs.Options.Gif.Save.UseAnimationPalette = imageInfo.Gif.HasAnimationPalette;
rasterCodecs.Options.Gif.Save.AnimationWidth = imageInfo.Gif.AnimationWidth;
rasterCodecs.Options.Gif.Save.AnimationHeight = imageInfo.Gif.AnimationHeight;
}
img = rasterCodecs.Load(sourceImage);
// Load convert action profile
if (Init(sourceImage, strActionProfile))
{
// loop on actions
LoopActions();
SaveImage();
// add a copyright or something like this to the image
if (xmlActionProfile.SelectSingleNode("//root/actionProfile[@ID='" + strActionProfile + "']/action[@ID='annotate']") != null && strTargetImage.Length > 0)
{
Annotate();
}
if (retPath == ReturnPath.AbsPath)
{
strRetFile = strTargetImage;
}
else if (retPath == ReturnPath.Url)
{
strRetFile = strTargetImageUrl;
}
}
}
finally
{
img.Dispose();
RasterCodecs.Shutdown();
}
return(strRetFile);
}
/// <summary>
/// Called by the owner to initialize
/// </summary>
public void SetData(CodecsImageInfo imageInfo, RasterCodecs rasterCodecsInstance)
{
// Set the state of the controls
if (imageInfo != null)
{
// Get the index of the format in the DocumentFormats
int index = Tools.DocumentFormats.GetFormatIndex(imageInfo.Format);
CodecsRasterizeDocumentUnit viewUnit = rasterCodecsInstance.Options.RasterizeDocument.Load.Unit;
double originalWidth;
double originalHeight;
CodecsRasterizeDocumentUnit originalUnit;
if (index != -1)
{
// Document format
_formatValueLabel.Text = string.Format("{0} ({1})", Tools.DocumentFormats.FormatFriendlyNames[index], Tools.DocumentFormats.Formats[index]);
originalWidth = imageInfo.Document.PageWidth;
originalHeight = imageInfo.Document.PageHeight;
originalUnit = imageInfo.Document.Unit;
_warningLabel.Visible = false;
}
else
{
// Raster format
_formatValueLabel.Text = imageInfo.Format.ToString();
originalWidth = imageInfo.Width;
originalHeight = imageInfo.Height;
originalUnit = CodecsRasterizeDocumentUnit.Pixel;
_warningLabel.Visible = true;
}
_pagesValueLabel.Text = imageInfo.TotalPages.ToString();
// Convert to the view unit
originalWidth = Tools.Units.Convert(originalWidth, originalUnit, Tools.Units.ScreenResolution, viewUnit);
originalHeight = Tools.Units.Convert(originalHeight, originalUnit, Tools.Units.ScreenResolution, viewUnit);
_originalDocumentSizeValueLabel.Text = Tools.Units.Format(originalWidth, originalHeight, viewUnit);
double loadWidth = Tools.Units.Convert(imageInfo.Width, CodecsRasterizeDocumentUnit.Pixel, imageInfo.XResolution, viewUnit);
double loadHeight = Tools.Units.Convert(imageInfo.Height, CodecsRasterizeDocumentUnit.Pixel, imageInfo.YResolution, viewUnit);
_loadDocumentSizeValueLabel.Text = Tools.Units.Format(loadWidth, loadHeight, viewUnit);
_loadDocumentSizePixelsLabel.Text = string.Format("{0} at {1} pixels/inch", Tools.Units.Format(imageInfo.Width, imageInfo.Height, CodecsRasterizeDocumentUnit.Pixel), imageInfo.XResolution);
// Show everything
_formatValueLabel.Visible = true;
_pagesValueLabel.Visible = true;
_originalDocumentSizeValueLabel.Visible = true;
_loadDocumentSizeValueLabel.Visible = true;
_loadDocumentSizePixelsLabel.Visible = true;
}
else
{
// Hide everything
_formatValueLabel.Visible = false;
_pagesValueLabel.Visible = false;
_originalDocumentSizeValueLabel.Visible = false;
_loadDocumentSizeValueLabel.Visible = false;
_loadDocumentSizePixelsLabel.Visible = false;
_warningLabel.Visible = false;
}
}
/// <summary>
/// Load a new image
/// </summary>
private void _miFileOpen_Click(object sender, System.EventArgs e)
{
RasterCodecs _codecs = null;
CodecsImageInfo imageInfo = null;
try
{
// initialize the codecs object.
_codecs = new RasterCodecs();
// Since we are dealing with large images, we do not want to allocate the entire image. We are only going to load it row by row
_codecs.Options.Load.AllocateImage = false;
_codecs.Options.Load.StoreDataInImage = false;
_codecs.LoadImage += new EventHandler <CodecsLoadImageEventArgs>(codecs_LoadImage);
// load the image
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Title = "Open File";
openFileDialog.Multiselect = false;
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
//Check if image is valid for this demo
imageInfo = _codecs.GetInformation(openFileDialog.FileName, false);
if (!IsImageValid(imageInfo))
{
Messager.ShowError(this, "The input image has to be 8-bit Gray scale, 12-bit Gray scale, 16-bit Gray scale, RGB (color), and TopLeft view perspective." +
" This DEMO is not meant to be used with small or palletized images (like GIF, PNG, or 1-bit images)." +
" Use this DEMO to save large dimension images efficiently using JPEG2000 compression.");
return;
}
using (RasterSaveDialog saveDialog = new RasterSaveDialog(_codecs))
{
saveDialog.AutoProcess = false;
saveDialog.Title = "Save As";
saveDialog.ShowFileOptionsBasicJ2kOptions = true;
saveDialog.ShowFileOptionsJ2kOptions = true;
saveDialog.ShowOptions = true;
saveDialog.ShowQualityFactor = true;
saveDialog.ShowFileOptionsProgressive = true;
saveDialog.ShowFileOptionsStamp = true;
saveDialog.QualityFactor = 20;
SetupFormats(saveDialog);
if (saveDialog.ShowDialog(this) != DialogResult.OK)
{
return;
}
_lblFilenameValue.Text = Path.GetFileName(openFileDialog.FileName);
_lblDimensionValue.Text = String.Format("{0} x {1}", imageInfo.Width, imageInfo.Height);
_lblImageBitsPerPixelValue.Text = imageInfo.BitsPerPixel.ToString();
//Get the selected compression type
CodecsCompression selectedCompression;
if (saveDialog.Format == RasterImageFormat.J2k)
{
selectedCompression = CodecsCompression.J2k;
}
else
{
selectedCompression = CodecsCompression.Jp2;
}
RasterByteOrder rasterByteOrder = ((saveDialog.BitsPerPixel == 12) || (saveDialog.BitsPerPixel == 16)) ? RasterByteOrder.Gray : RasterByteOrder.Bgr;
CodecsLoadByteOrder codecsLoadByteOrder = ((saveDialog.BitsPerPixel == 12) || (saveDialog.BitsPerPixel == 16)) ? CodecsLoadByteOrder.Gray : CodecsLoadByteOrder.Bgr;
bytesPerLine = CalculateBytesPerLine(saveDialog.BitsPerPixel, imageInfo.Width);
_codecs.Options.Jpeg.Save.QualityFactor = saveDialog.QualityFactor;
_codecs.Options.Jpeg.Save.Passes = saveDialog.Passes;
_codecs.Options.Jpeg.Save.SaveWithStamp = saveDialog.WithStamp;
_codecs.Options.Jpeg.Save.StampWidth = saveDialog.StampWidth;
_codecs.Options.Jpeg.Save.StampHeight = saveDialog.StampHeight;
_codecs.Options.Jpeg.Save.StampBitsPerPixel = saveDialog.StampBitsPerPixel;
_codecs.Options.Jpeg2000.Save.CompressionControl = saveDialog.FileJ2kOptions.CompressionControl;
_codecs.Options.Jpeg2000.Save.CompressionRatio = saveDialog.FileJ2kOptions.CompressionRatio;
_codecs.Options.Jpeg2000.Save.DecompositionLevels = saveDialog.FileJ2kOptions.DecompositionLevels;
_codecs.Options.Jpeg2000.Save.DerivedQuantization = saveDialog.FileJ2kOptions.DerivedQuantization;
_codecs.Options.Jpeg2000.Save.ImageAreaHorizontalOffset = saveDialog.FileJ2kOptions.ImageAreaHorizontalOffset;
_codecs.Options.Jpeg2000.Save.ImageAreaVerticalOffset = saveDialog.FileJ2kOptions.ImageAreaVerticalOffset;
_codecs.Options.Jpeg2000.Save.ProgressingOrder = saveDialog.FileJ2kOptions.ProgressingOrder;
_codecs.Options.Jpeg2000.Save.ReferenceTileHeight = saveDialog.FileJ2kOptions.ReferenceTileHeight;
_codecs.Options.Jpeg2000.Save.ReferenceTileWidth = saveDialog.FileJ2kOptions.ReferenceTileWidth;
_codecs.Options.Jpeg2000.Save.RegionOfInterest = saveDialog.FileJ2kOptions.RegionOfInterest;
_codecs.Options.Jpeg2000.Save.RegionOfInterestRectangle = saveDialog.FileJ2kOptions.RegionOfInterestRectangle;
_codecs.Options.Jpeg2000.Save.RegionOfInterestWeight = saveDialog.FileJ2kOptions.RegionOfInterestWeight;
_codecs.Options.Jpeg2000.Save.TargetFileSize = saveDialog.FileJ2kOptions.TargetFileSize;
_codecs.Options.Jpeg2000.Save.TileHorizontalOffset = saveDialog.FileJ2kOptions.TileHorizontalOffset;
_codecs.Options.Jpeg2000.Save.TileVerticalOffset = saveDialog.FileJ2kOptions.TileVerticalOffset;
_codecs.Options.Jpeg2000.Save.UseColorTransform = saveDialog.FileJ2kOptions.UseColorTransform;
_codecs.Options.Jpeg2000.Save.UseEphMarker = saveDialog.FileJ2kOptions.UseEphMarker;
_codecs.Options.Jpeg2000.Save.UseRegionOfInterest = saveDialog.FileJ2kOptions.UseRegionOfInterest;
_codecs.Options.Jpeg2000.Save.UseSopMarker = saveDialog.FileJ2kOptions.UseSopMarker;
bCancel = false;
bCompressing = true;
UpdateMyControls();
//Start Compressing
using (outputFile = File.Create(saveDialog.FileName))
{
_codecs.StartCompress(imageInfo.Width, imageInfo.Height, saveDialog.BitsPerPixel, rasterByteOrder, RasterViewPerspective.TopLeft, bytesPerLine, IntPtr.Zero, 0, selectedCompression, MyCodecsCompressDataCallback);
_codecs.Load(openFileDialog.FileName, saveDialog.BitsPerPixel, codecsLoadByteOrder, 1, 1);
_codecs.StopCompress();
_lblStatusValue.Text = bCancel ? "Aborted" : "Complete";
}
}
}
}
catch (Exception ex)
{
Messager.ShowError(this, ex);
_lblStatusValue.Text = "Error";
}
finally
{
if (_codecs != null)
{
_codecs.Dispose();
}
if (imageInfo != null)
{
imageInfo.Dispose();
}
bCompressing = false;
UpdateMyControls();
}
}
public void Convert(string origFile, string fromFile, string outputDir, string processedDir, string callerRef, string sentTo)
{
RasterImage image = null;
try
{
FileInfo fileInfo = new FileInfo(fromFile);
if (!fileInfo.Exists)
{
_logFile.WriteToLog("Lead Tool Converter - ERROR: " + fromFile + " does not exist.");
return;
}
string srcFileName = fileInfo.Name;
_logFile.WriteToLog("Lead Tool Converter: Conversion starting.");
string srcFileNameWithoutExt = Path.GetFileNameWithoutExtension(srcFileName);
string outputFileName = outputDir + @"\" + srcFileNameWithoutExt + "_" + DateTime.Now.ToString("yyyyMMddhh24mmss") + ".tif";
string fileExt = fileInfo.Extension.ToLower();
LoadOptionValues(codec, fileExt);
CodecsImageInfo info = codec.GetInformation(fromFile, true);
image = codec.Load(fromFile, 0, CodecsLoadByteOrder.Bgr, 1, info.TotalPages);
codec.Save(image, outputFileName, RasterImageFormat.Tif, 1, 1, info.TotalPages, 1, CodecsSavePageMode.Overwrite);
_logFile.WriteToLog("Lead Tool Converter: Conversion completed.");
//jvc insert Inbound - Data Access here
InboundController ibController = new InboundController();
ibController._logFile = _logFile;
_logFile.WriteToLog("InboundController Started: Saving Info to Database for source file:" + origFile + " and converted file: " + outputFileName);
ibController.ProcessFile(outputFileName, origFile, callerRef, sentTo); //jvc tif and original source format
if (Properties.Settings.Default.DeleteTIFEnabled)
{
File.Delete(outputFileName);
}
_logFile.WriteToLog("InboundController Completed: File Info saved to Database.");
}
catch (RasterException ex)
{
string erMsg = "";
if (ex.Code == RasterExceptionCode.FileFormat)
{
erMsg = "The file ''" + fromFile + "'' does not contain an image format recognizable by LEADTOOLS;" + Environment.NewLine + ex.Message;
}
else if (ex.Code == RasterExceptionCode.InvalidFormat)
{
erMsg = "The file ''" + fromFile + "'' does not contain an format recognizable by LEADTOOLS;" + Environment.NewLine + ex.Message;
}
else
{
erMsg = "Could not load the file ''" + fromFile + "''; " + Environment.NewLine + "Leadtools code: " + ex.Code + "; message: " + ex.Message;
}
_logFile.WriteToLog(erMsg);
throw new Exception(erMsg);
}
catch (Exception e)
{
_logFile.WriteToLog("Lead Tool Converter - ERROR: " + e.Message + "; Stack - " + e.StackTrace);
throw e;
}
finally
{
if (image != null)
{
image.Dispose();
}
}
}
//Use this load to load an image using the open dialog
public int Load(IWin32Window owner, RasterCodecs codecs, bool autoLoad)
{
using (RasterOpenDialog ofd = new RasterOpenDialog(codecs))
{
ofd.DereferenceLinks = true;
ofd.CheckFileExists = false;
ofd.CheckPathExists = true;
ofd.EnableSizing = true;
ofd.Filter = Filters;
ofd.FilterIndex = _filterIndex;
ofd.LoadFileImage = false;
ofd.LoadOptions = false;
ofd.LoadRotated = true;
ofd.LoadCompressed = true;
ofd.LoadMultithreaded = codecs.Options.Jpeg.Load.Multithreaded;
ofd.ShowLoadMultithreaded = true;
ofd.Multiselect = _multiSelect;
ofd.ShowGeneralOptions = true;
ofd.ShowLoadCompressed = true;
ofd.ShowLoadOptions = true;
ofd.ShowLoadRotated = true;
ofd.ShowMultipage = true;
ofd.UseGdiPlus = UseGdiPlus;
ofd.ShowPdfOptions = ShowPdfOptions;
ofd.ShowXpsOptions = ShowXpsOptions;
ofd.ShowXlsOptions = ShowXlsOptions;
ofd.ShowRasterizeDocumentOptions = ShowRasterizeDocumentOptions;
ofd.EnableFileInfoModeless = true;
ofd.EnableFileInfoResizing = true;
ofd.ShowVffOptions = ShowVffOptions;
ofd.ShowAnzOptions = ShowAnzOptions;
ofd.ShowVectorOptions = ShowVectorOptions;
ofd.ShowPreview = true;
ofd.ShowProgressive = true;
ofd.ShowRasterOptions = true;
ofd.ShowTotalPages = true;
ofd.ShowDeletePage = true;
ofd.ShowFileInformation = true;
ofd.UseFileStamptoPreview = true;
ofd.PreviewWindowVisible = true;
ofd.Title = "LEADTOOLS Open Dialog";
ofd.FileName = FileName;
ofd.LoadCorrupted = LoadCorrupted;
ofd.PreferVector = PreferVector;
if (!String.IsNullOrEmpty(_openDialogInitialPath))
{
ofd.InitialDirectory = _openDialogInitialPath;
}
if (ofd.ShowDialog(owner) == DialogResult.OK)
{
foreach (RasterDialogFileData item in ofd.OpenedFileData)
{
FileName = item.Name;
_filterIndex = ofd.FilterIndex;
// Set the RasterizeDocument load options before calling GetInformation
codecs.Options.RasterizeDocument.Load.PageWidth = item.Options.RasterizeDocumentOptions.PageWidth;
codecs.Options.RasterizeDocument.Load.PageHeight = item.Options.RasterizeDocumentOptions.PageHeight;
codecs.Options.RasterizeDocument.Load.LeftMargin = item.Options.RasterizeDocumentOptions.LeftMargin;
codecs.Options.RasterizeDocument.Load.TopMargin = item.Options.RasterizeDocumentOptions.TopMargin;
codecs.Options.RasterizeDocument.Load.RightMargin = item.Options.RasterizeDocumentOptions.RightMargin;
codecs.Options.RasterizeDocument.Load.BottomMargin = item.Options.RasterizeDocumentOptions.BottomMargin;
codecs.Options.RasterizeDocument.Load.Unit = item.Options.RasterizeDocumentOptions.Unit;
codecs.Options.RasterizeDocument.Load.XResolution = item.Options.RasterizeDocumentOptions.XResolution;
codecs.Options.RasterizeDocument.Load.YResolution = item.Options.RasterizeDocumentOptions.YResolution;
codecs.Options.RasterizeDocument.Load.SizeMode = item.Options.RasterizeDocumentOptions.SizeMode;
if (item.FileInfo.Format == RasterImageFormat.Afp || item.FileInfo.Format == RasterImageFormat.Ptoca)
{
codecs.Options.Ptoka.Load.Resolution = codecs.Options.RasterizeDocument.Load.XResolution;
}
// Set the user Options
codecs.Options.Load.Passes = item.Passes;
codecs.Options.Load.Rotated = item.LoadRotated;
codecs.Options.Load.Compressed = item.LoadCompressed;
codecs.Options.Load.LoadCorrupted = ofd.LoadCorrupted;
codecs.Options.Load.PreferVector = ofd.PreferVector;
codecs.Options.Jpeg.Load.Multithreaded = item.LoadMultithreaded;
switch (item.Options.FileType)
{
case RasterDialogFileOptionsType.Meta:
{
// Set the user options
codecs.Options.Wmf.Load.XResolution = item.Options.MetaOptions.XResolution;
codecs.Options.Wmf.Load.YResolution = item.Options.MetaOptions.XResolution;
break;
}
case RasterDialogFileOptionsType.Pdf:
{
if (codecs.Options.Pdf.Load.UsePdfEngine)
{
// Set the user options
codecs.Options.Pdf.Load.DisplayDepth = item.Options.PdfOptions.DisplayDepth;
codecs.Options.Pdf.Load.GraphicsAlpha = item.Options.PdfOptions.GraphicsAlpha;
codecs.Options.Pdf.Load.TextAlpha = item.Options.PdfOptions.TextAlpha;
codecs.Options.Pdf.Load.UseLibFonts = item.Options.PdfOptions.UseLibFonts;
}
break;
}
case RasterDialogFileOptionsType.Misc:
{
switch (item.FileInfo.Format)
{
case RasterImageFormat.Jbig:
{
// Set the user options
codecs.Options.Jbig.Load.Resolution = new LeadSize(item.Options.MiscOptions.XResolution,
item.Options.MiscOptions.YResolution);
break;
}
case RasterImageFormat.Cmw:
{
// Set the user options
codecs.Options.Jpeg2000.Load.CmwResolution = new LeadSize(item.Options.MiscOptions.XResolution,
item.Options.MiscOptions.YResolution);
break;
}
case RasterImageFormat.Jp2:
{
// Set the user options
codecs.Options.Jpeg2000.Load.Jp2Resolution = new LeadSize(item.Options.MiscOptions.XResolution,
item.Options.MiscOptions.YResolution);
break;
}
case RasterImageFormat.J2k:
{
// Set the user options
codecs.Options.Jpeg2000.Load.J2kResolution = new LeadSize(item.Options.MiscOptions.XResolution,
item.Options.MiscOptions.YResolution);
break;
}
}
break;
}
case RasterDialogFileOptionsType.Xls:
{
// Set the user options
codecs.Options.Xls.Load.MultiPageSheet = item.Options.XlsOptions.MultiPageSheet;
codecs.Options.Xls.Load.ShowHiddenSheet = item.Options.XlsOptions.ShowHiddenSheet;
#if LEADTOOLS_V20_OR_LATER
codecs.Options.Xls.Load.MultiPageUseSheetWidth = item.Options.XlsOptions.MultiPageUseSheetWidth;
codecs.Options.Xls.Load.PageOrderDownThenOver = item.Options.XlsOptions.PageOrderDownThenOver;
codecs.Options.Xls.Load.MultiPageEnableMargins = item.Options.XlsOptions.MultiPageEnableMargins;
#endif //#if LEADTOOLS_V20_OR_LATER
}
break;
case RasterDialogFileOptionsType.Vff:
{
codecs.Options.Vff.Load.View = item.Options.VffOptions.View;
break;
}
case RasterDialogFileOptionsType.Anz:
{
codecs.Options.Anz.Load.View = item.Options.AnzOptions.View;
break;
}
case RasterDialogFileOptionsType.Vector:
{
codecs.Options.Vector.Load.BackgroundColor = item.Options.VectorOptions.Options.BackgroundColor;
codecs.Options.Vector.Load.BitsPerPixel = item.Options.VectorOptions.Options.BitsPerPixel;
codecs.Options.Vector.Load.ForceBackgroundColor = item.Options.VectorOptions.Options.ForceBackgroundColor;
codecs.Options.Vector.Load.ViewHeight = item.Options.VectorOptions.Options.ViewHeight;
codecs.Options.Vector.Load.ViewMode = item.Options.VectorOptions.Options.ViewMode;
codecs.Options.Vector.Load.ViewWidth = item.Options.VectorOptions.Options.ViewWidth;
break;
}
}
int firstPage = 1;
int lastPage = 1;
int infoTotalPages;
CodecsImageInfo info = null;
using (WaitCursor wait = new WaitCursor())
{
info = codecs.GetInformation(FileName, true);
infoTotalPages = info.TotalPages;
}
if (_showLoadPagesDialog)
{
firstPage = 1;
lastPage = infoTotalPages;
if (firstPage != lastPage)
{
using (ImageFileLoaderPagesDialog dlg = new ImageFileLoaderPagesDialog(infoTotalPages, LoadOnlyOnePage))
{
if (dlg.ShowDialog(owner) == DialogResult.OK)
{
firstPage = dlg.FirstPage;
lastPage = dlg.LastPage;
}
else
{
if (info != null)
{
info.Dispose();
}
return(0);
}
}
}
}
else
{
firstPage = item.PageNumber;
lastPage = item.PageNumber;
}
_firstPage = firstPage;
_lastPage = lastPage;
if (!SetDocumentLoadResultion(codecs, info, firstPage, lastPage))
{
info.Dispose();
return(0);
}
if (autoLoad)
{
using (WaitCursor wait = new WaitCursor())
{
_image = codecs.Load(FileName, 0, CodecsLoadByteOrder.BgrOrGray, firstPage, lastPage);
if (codecs.LoadStatus != RasterExceptionCode.Success)
{
String message = String.Format("The image was only partially loaded due to error: {0}", codecs.LoadStatus.ToString());
Messager.Show(null, message, MessageBoxIcon.Information, MessageBoxButtons.OK);
}
if (_image != null)
{
_image.CustomData.Add("IsBigTiff", info.Tiff.IsBigTiff);
_images.Add(new ImageInformation(_image, item.Name));
}
}
}
info.Dispose();
}
}
return(ofd.OpenedFileData.Count);
}
}
private void OpenSelectedAttachment()
{
if (_lstAttachments.SelectedItems.Count > 0)
{
int selectedIndex = _lstAttachments.SelectedIndices[0];
string attahmentFileName = _lstAttachments.Items[selectedIndex].Text;
string tempPath = Path.GetTempPath();
string tempAttachmentFile = Path.Combine(Path.GetTempPath(), string.Format("LT_CS_{0}.tmp", attahmentFileName));
if (File.Exists(tempAttachmentFile))
{
File.Delete(tempAttachmentFile);
}
ExtractAttachmentFile(tempAttachmentFile, selectedIndex + 1);
if (File.Exists(tempAttachmentFile))
{
try
{
using (CodecsImageInfo info = _codecs.GetInformation(tempAttachmentFile, true))
{
if (info.AttachmentCount > 0)
{
if (info.IsPortfolio)
{
PortfolioMsgForm portfolioMsgFrm = new PortfolioMsgForm();
portfolioMsgFrm._fileName = tempAttachmentFile;
portfolioMsgFrm._codecs = _codecs;
portfolioMsgFrm._parentForm = _parent;
portfolioMsgFrm.ShowDialog(this);
}
else
{
AttachmentMsgForm attachmentMsgFrm = new AttachmentMsgForm();
attachmentMsgFrm._fileName = tempAttachmentFile;
attachmentMsgFrm._firstPage = 1;
attachmentMsgFrm._lastPage = info.TotalPages;
attachmentMsgFrm._codecs = _codecs;
attachmentMsgFrm._parentForm = _parent;
attachmentMsgFrm.ShowDialog(this);
}
}
else
{
_parent.LoadFile(tempAttachmentFile, 1, info.TotalPages, attahmentFileName);
}
}
}
catch (Exception ex)
{
Messager.ShowError(this, ex);
}
File.Delete(tempAttachmentFile);
}
}
else
{
MessageBox.Show(this, "No selected attachment!", "Notice!");
}
}
private static void SetRecommendedLoadingOptions(RasterCodecs rasterCodecs, CodecsImageInfo info, long maximumMemorySize)
{
// Do not throw exceptions if we cannot read the file, not our job
var savedValue = rasterCodecs.ThrowExceptionsOnInvalidImages;
try
{
bool forceDiskMemory = false;
bool saveLoadDiskMemory = rasterCodecs.Options.Load.DiskMemory;
bool saveLoadCompressed = rasterCodecs.Options.Load.Compressed;
bool saveLoadSuperCompressed = rasterCodecs.Options.Load.SuperCompressed;
int resolution = 300;//always start with 300
int newResolution = resolution;
if (maximumMemorySize > 0) //0 means unlimited memory available!
{
if (info.SizeMemory > maximumMemorySize)
{
// Is this a document file format that uses resolution?
if (info.Document.IsDocumentFile)
{
// Calculate the exact new resolution
long size = info.Width * info.Height * info.BitsPerPixel / 8;
newResolution = (int)((double)resolution * (double)Math.Sqrt((double)maximumMemorySize / (double)size));
// These are the DPI's to try, everything else is not a standard value and we dont want it
// so find the closest to ours
int[] validResolutions = { 200, 150, 96, 72 };
int validIndex = -1;
for (int i = 0; i < validResolutions.Length && validIndex == -1; i++)
{
if (newResolution > validResolutions[i])
{
validIndex = i;
}
}
if (validIndex == -1)
{
validIndex = validResolutions.Length - 1;
}
// Re-calculate the size of memory with new resolution
double widthInInches = (double)info.Width / (double)info.XResolution;
double heightInInches = (double)info.Height / (double)info.YResolution;
newResolution = validResolutions[validIndex];
size = (long)((widthInInches * newResolution) * (heightInInches * newResolution) * info.BitsPerPixel / 8);
if (size > maximumMemorySize)
{
forceDiskMemory = true;
}
}
else
{
forceDiskMemory = true;
}
}
else
{
forceDiskMemory = false;
}
}
if (newResolution != resolution)
{
rasterCodecs.Options.RasterizeDocument.Load.XResolution = newResolution;
rasterCodecs.Options.RasterizeDocument.Load.YResolution = newResolution;
}
if (forceDiskMemory)
{
rasterCodecs.Options.Load.DiskMemory = true;
rasterCodecs.Options.Load.Compressed = false;
rasterCodecs.Options.Load.SuperCompressed = false;
}
}
finally
{
// reset
rasterCodecs.ThrowExceptionsOnInvalidImages = savedValue;
}
}
/// <summary>
/// Run the load command.
/// </summary>
/// <param name="id">Scanning session id.</param>
/// <param name="service">Twain scanning service handle.</param>
/// <param name="args">Load command arguments.</param>
public static void Run(string id, TwainScanningService service, LoadCommandArgs args)
{
if (args.Uri == null)
{
throw new ArgumentNullException("Uri");
}
if (args.StartPage < 0)
{
throw new ArgumentOutOfRangeException("StartPage", "must be a value greater than or equal to 1");
}
if (args.Resolution < 0)
{
throw new ArgumentOutOfRangeException("Resolution", "must be a value greater than or equals to 0");
}
// Force the uri to be fully qualified, reject everything else for security reasons
if (args.Uri.IsFile || args.Uri.IsUnc)
{
throw new ArgumentException("URL cannot be local file or UNC path.");
}
// Use a temp file, much faster than calling Load/Info from a URI directly
// In a production service, you might want to create a caching mechanism
string tempFile = Path.GetTempFileName();
try
{
// Download the file
using (WebClient client = new WebClient())
client.DownloadFile(args.Uri, tempFile);
using (RasterCodecs codecs = new RasterCodecs())
{
DemoUtils.InitCodecs(codecs, args.Resolution);
CodecsImageInfo info = codecs.GetInformation(tempFile, true);
if ((args.EndPage < 0) || (args.EndPage > info.TotalPages))
{
args.EndPage = info.TotalPages;
}
for (int pageNumber = args.StartPage; pageNumber <= args.EndPage; pageNumber++)
{
using (RasterImage image = codecs.Load(tempFile, args.BitsPerPixel, CodecsLoadByteOrder.BgrOrGray, pageNumber, pageNumber))
{
service.AddPage(id, image);
}
}
}
}
finally
{
if (File.Exists(tempFile))
{
try
{
File.Delete(tempFile);
}
catch
{
// Do nothing.
}
}
}
}
private void _btnStart_Click(object sender, EventArgs e)
{
bool sourceHasAnnFiles = false;
try
{
//check if source exist.
if (!Directory.Exists(_txtSourceDirectory.Text))
{
MessageBox.Show("The source directory is not existing", "Incorrect source directory", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
//check if destination exist.
if (!Directory.Exists(_txtDestinationDirectory.Text))
{
Directory.CreateDirectory(_txtDestinationDirectory.Text);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
_converting = true;
_lvResults.Items.Clear();
UpdateButtons();
int index = 0;
string[] srcFolderFiles = Directory.GetFiles(_txtSourceDirectory.Text, "*.*", SearchOption.TopDirectoryOnly);
foreach (string srcAnnotationFile in srcFolderFiles.Where(ext => ext.ToLower().EndsWith(".ann") ||
ext.ToLower().EndsWith(".xml") || ext.ToLower().EndsWith(".tif") || ext.ToLower().EndsWith(".pdf")))
{
Application.DoEvents();
ConversionInfo conversionInfo = new ConversionInfo();
conversionInfo.SourcePath = srcAnnotationFile;
string destAnnotationFile = string.Format("{0}.xml", Path.Combine(_txtDestinationDirectory.Text, Path.GetFileNameWithoutExtension(srcAnnotationFile)));
conversionInfo.DestinationPath = destAnnotationFile;
try
{
AnnContainer[] containers = null;
double dpiX = 96.0;
double dpiY = 96.0;
//try to get the relative image for this annotations file assuming it is located behind the annotations file , if it is not exist then take the default dpi 96*96
string relativeImageFile = string.Empty;
string fileExt = Path.GetExtension(srcAnnotationFile);
if (fileExt.ToLower() == ".tif" || fileExt.ToLower() == ".pdf")
{
//the annotations is embedded inside the file
relativeImageFile = srcAnnotationFile;
}
else
{
foreach (string file in srcFolderFiles)
{
if (Path.GetFileNameWithoutExtension(file) == Path.GetFileNameWithoutExtension(srcAnnotationFile) &&
Path.GetExtension(file).ToLower() != ".xml" &&
Path.GetExtension(file).ToLower() != ".ann")
{
relativeImageFile = file;
}
}
}
try
{
if (relativeImageFile != string.Empty)
{
using (RasterCodecs codecs = new RasterCodecs())
{
CodecsImageInfo imageInfo = codecs.GetInformation(relativeImageFile, false);
dpiX = imageInfo.XResolution;
dpiY = imageInfo.YResolution;
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
AnnCodecs annCodecs = new AnnCodecs();
containers = annCodecs.LoadAll(srcAnnotationFile, dpiX, dpiY);
conversionInfo.Result = ConversionResult.Success;
using (Stream stream = File.OpenWrite(destAnnotationFile))
{
annCodecs.SaveAll(stream, containers, AnnFormat.Annotations);
}
conversionInfo.Page = index + 1;
index++;
AddConversionUpdate(conversionInfo);
sourceHasAnnFiles = true;
}
catch (Exception)
{
conversionInfo.Result = ConversionResult.Failed;
AddConversionUpdate(conversionInfo);
continue;
}
}
_converting = false;
UpdateButtons();
if (sourceHasAnnFiles)
{
MessageBox.Show("Conversion Complete", "Complete", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
else
{
MessageBox.Show("There is no valid annotation file in source directory", "No source annotations", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
