public void LoadTest078()
{
string file = Path.Combine(Util.ArtifactsPath, "test078C.djvu");
using (DjvuDocument document = new DjvuDocument())
{
int hash = file.GetHashCode();
document.Load(file, hash);
Assert.Equal(hash, document.Identifier);
IDjvuPage page = document.ActivePage;
PM44Chunk pmChunk = page.PageForm.Children[0] as PM44Chunk;
Assert.IsType <PM44Chunk>(pmChunk);
var img = pmChunk.Image;
Assert.NotNull(img);
var pixMap = new Wavelet.InterWavePixelMapDecoder();
pixMap = pmChunk.ProgressiveDecodeBackground(pixMap) as Wavelet.InterWavePixelMapDecoder;
Assert.NotNull(pixMap);
pmChunk = page.PageForm.Children[1] as PM44Chunk;
Assert.NotNull(pmChunk);
var pixMap2 = new Wavelet.InterWavePixelMapDecoder();
Assert.Throws <DjvuFormatException>(() => pmChunk.ProgressiveDecodeBackground(pixMap2));
// This time call will not throw
pmChunk.ProgressiveDecodeBackground(pixMap);
}
}
public async Task <IBook> AddBookAsync(IStorageFile file)
{
if (file == null)
{
throw new ArgumentNullException(nameof(file));
}
var document = await DjvuDocument.LoadAsync(file);
var bookDto = new EfBookDto
{
PageCount = document.PageCount,
Title = Path.GetFileNameWithoutExtension(file.Name),
LastOpeningTime = DateTime.Now
};
_context.Books.Add(bookDto);
await _context.SaveChangesAsync();
var booksFolder = await ApplicationData.Current.LocalFolder.CreateFolderAsync("Books", CreationCollisionOption.OpenIfExists);
var bookFile = await file.CopyAsync(booksFolder, $"{bookDto.Id}.djvu", NameCollisionOption.ReplaceExisting);
bookDto.BookPath = bookFile.Path;
await _context.SaveChangesAsync();
var book = new EfBook(bookDto, _context, _books);
await book.UpdateThumbnailAsync();
_books.Add(book);
return(book);
}
public void Properties003()
{
int pageCount = Util.GetTestDocumentPageCount(3);
string file = Util.GetTestFilePath(3);
int identifier = 3;
using (DjvuDocument document = new DjvuDocument(file, identifier))
{
Util.VerifyDjvuDocumentCtor(pageCount, document);
Assert.Equal(identifier, document.Identifier);
Assert.False(String.IsNullOrWhiteSpace(document.Name));
Assert.StartsWith(file, document.Location);
Assert.False(document.IsInverted);
Assert.NotNull(document.NextPage);
// TODO change list logic - if first page is current
// than previous page should be null
//Assert.Null(document.PreviousPage);
string testLocation = "http:://web.site";
document.IsInverted = true;
Assert.True(document.IsInverted);
document.Location = testLocation;
Assert.Equal(testLocation, document.Location);
document.Identifier = int.MinValue;
Assert.Equal(int.MinValue, document.Identifier);
var includes = document.Includes;
Assert.NotNull(includes);
Assert.Equal(11, includes.Count);
}
}
public void IsDjvuDocument_String004()
{
string filePath = Path.GetTempFileName() + "1.djvu";
FileStream fs = null;
try
{
try
{
fs = File.Create(filePath);
fs.Write(DjvuDocument.MagicBuffer, 0, DjvuDocument.MagicBuffer.Length);
fs.Write(DjvuDocument.MagicBuffer, 0, DjvuDocument.MagicBuffer.Length);
fs.WriteByte(0x4e);
fs.Flush();
}
finally
{
fs.Close();
}
bool result = DjvuDocument.IsDjvuDocument(filePath);
Assert.True(result);
}
finally
{
if (File.Exists(filePath))
{
File.Delete(filePath);
}
}
}
public void BuildMaskImage_Theory(int docNumber, double tolerance)
{
int pageCount = 0;
using (DjvuDocument document = Util.GetTestDocument(docNumber, out pageCount))
{
Util.VerifyDjvuDocument(pageCount, document);
IDjvuPage page = document.FirstPage;
var testImagePath = Path.Combine(Util.RepoRoot, "artifacts", "data", $"test{docNumber:00#}Cmask.png");
DjvuImage djvuImage = page.Image as DjvuImage;
using (Bitmap image = djvuImage.GetMaskImage(1, true))
using (Bitmap testImage = new Bitmap(testImagePath))
{
Assert.NotNull(image);
Assert.IsType <Bitmap>(image);
using Bitmap invertedImage = DjvuImage.InvertImage(image);
bool result = Util.CompareImagesForBinarySimilarity(testImage, invertedImage, tolerance, true, $"Testing Djvu mask: \t\ttest{docNumber:00#}C.png, ");
#if DUMP_IMAGES
DumpIage(docNumber, image, "Mask");
#endif
Assert.True(result);
}
}
}
private static void DumpPageNodes(string filePath, DjvuDocument document)
{
try
{
string path = Path.GetDirectoryName(filePath);
string fileName = Path.GetFileNameWithoutExtension(filePath);
path = Path.Combine(path, "data");
var page = document.Pages[0];
var children = page.PageForm.Children;
Dictionary <string, int> dict = new Dictionary <string, int>();
foreach (IDjvuNode node in children)
{
if (dict.ContainsKey(node.Name))
{
dict[node.Name] += 1;
}
else
{
dict.Add(node.Name, 0);
}
string nameExt = node.Name == "BG44" || node.Name == "Incl" ? $"_P01_{dict[node.Name]}." : "_P01.";
string file = Path.Combine(path, fileName + nameExt + node.Name.ToLower());
using (FileStream fs = File.Create(file))
using (BinaryWriter writer = new BinaryWriter(fs))
{
byte[] buffer = node.ChunkData;
writer.Write(buffer, 0, buffer.Length);
}
}
}
catch
{
}
}
public void IsDjvuDocument_String005()
{
string filePath = Path.GetTempFileName() + "2.djvu";
FileStream fs = null;
try
{
try
{
fs = File.Create(filePath);
byte[] buffer = new byte[DjvuDocument.MagicBuffer.Length];
Buffer.BlockCopy(DjvuDocument.MagicBuffer, 0, buffer, 0, buffer.Length);
Array.Reverse(buffer);
fs.Write(buffer, 0, buffer.Length);
fs.Write(buffer, 0, buffer.Length);
fs.WriteByte(0x4e);
fs.Flush();
}
finally
{
fs.Close();
}
bool result = DjvuDocument.IsDjvuDocument(filePath);
Assert.False(result);
}
finally
{
if (File.Exists(filePath))
{
File.Delete(filePath);
}
}
}
public void BuildPageImageTest000()
{
string file = Path.Combine(Util.ArtifactsPath, "test077C.djvu");
using (DjvuDocument doc = new DjvuDocument(file))
{
var page = (DjvuPage)doc.Pages[0];
DjvuImage djvuImage = page.Image as DjvuImage;
using (var image = djvuImage.BuildPageImage())
{
page.IsInverted = true;
using (Bitmap imageInv = djvuImage.BuildPageImage())
{
Assert.NotNull(image);
Assert.NotNull(imageInv);
Assert.NotSame(image, imageInv);
Color pix = image.GetPixel(0, 0);
Color pixInv = imageInv.GetPixel(0, 0);
Assert.Equal(pix.R, 255 - pixInv.R);
Assert.Equal(pix.G, 255 - pixInv.G);
Assert.Equal(pix.B, 255 - pixInv.B);
}
}
}
}
public void GetMaskImage075()
{
int pageCount = 0;
using (DjvuDocument document = Util.GetTestDocument(75, out pageCount))
{
Util.VerifyDjvuDocument(pageCount, document);
DjvuPage page = document.FirstPage as DjvuPage;
Assert.NotNull(page);
var testImagePath = Path.Combine(Util.RepoRoot, "artifacts", "data", "test075C.mask.png");
DjvuImage djvuImage = page.Image as DjvuImage;
using (Bitmap image = djvuImage.GetMaskImage(1))
using (Bitmap testImage = new Bitmap(testImagePath))
{
Assert.NotNull(image);
Assert.IsType <Bitmap>(image);
Assert.NotNull(testImage);
bool result = Util.CompareImagesForBinarySimilarity(testImage, image, 0.3, true, "Testing Djvu mask: test075C.png, ");
Assert.True(result);
}
}
}
public void BuildImage_Theory(int docNumber)
{
int pageCount = 0;
using (DjvuDocument document = Util.GetTestDocument(docNumber, out pageCount))
{
Util.VerifyDjvuDocument(pageCount, document);
IDjvuPage page = document.FirstPage;
var testImagePath = Path.Combine(Util.RepoRoot, "artifacts", "data", $"test{docNumber:00#}C.png");
DjvuImage djvuImage = page.Image as DjvuImage;
using (Bitmap image = djvuImage.BuildImage())
using (Bitmap testImage = new Bitmap(testImagePath))
{
Assert.NotNull(image);
Assert.IsType <Bitmap>(image);
bool result = Util.CompareImagesForBinarySimilarity(testImage, image, docNumber == 75 ? 0.1485 : 0.0585, true, $"Testing Djvu image: \t\ttest{docNumber:00#}C.png, ");
#if DUMP_IMAGES
DumpImage(docNumber, image, "Img");
#endif
Assert.True(result, $"Test failed: ");
}
}
}
public void BuildForegroundImage_Theory(int docNumber)
{
int pageCount = 0;
using (DjvuDocument document = Util.GetTestDocument(docNumber, out pageCount))
{
Util.VerifyDjvuDocument(pageCount, document);
IDjvuPage page = document.FirstPage;
var testImagePath = Path.Combine(Util.RepoRoot, "artifacts", "data", $"test{docNumber:00#}CFgnd.png");
DjvuImage djvuImage = page.Image as DjvuImage;
using (Bitmap image = djvuImage.GetForegroundImage(1, true))
using (Bitmap testImage = new Bitmap(testImagePath))
{
Assert.NotNull(image);
Assert.IsType <Bitmap>(image);
if (image.Width != testImage.Width || image.Height != testImage.Height)
{
Assert.True(false, $"Unexpected image size differences. Width image: {image.Width} | testImage: {testImage.Width}, Height: image: {image.Height} | testImage {testImage.Height}");
}
bool result = Util.CompareImagesForBinarySimilarity(testImage, image, 0.025, true, $"Testing Djvu foreground: \ttest{docNumber:00#}C.png, ");
#if DUMP_IMAGES
DumpImage(docNumber, image, "Fgnd");
#endif
Assert.True(result);
}
}
}
public void Image003()
{
int pageCount = 0;
using (DjvuDocument document = Util.GetTestDocument(3, out pageCount))
{
Util.VerifyDjvuDocument(pageCount, document);
IDjvuPage page = document.FirstPage;
var testImagePath = Path.Combine(Util.ArtifactsDataPath, "test003C.png");
DjvuImage djvuImage = page.Image as DjvuImage;
using (var image = djvuImage.Image)
using (Bitmap testImage = new Bitmap(testImagePath))
{
Assert.NotNull(image);
Assert.IsType <Bitmap>(image);
Rectangle rect = new Rectangle(0, 0, image.Width, image.Height);
BitmapData data = image.LockBits(rect, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
BitmapData testData = testImage.LockBits(rect, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
bool result = Util.CompareImages(data, testData);
image.UnlockBits(data);
testImage.UnlockBits(testData);
//image.Save(Path.Combine(Util.RepoRoot, "artifacts", "data", "dumps", "test003CImage003n.png"));
//Assert.True(result);
}
}
}
public void DjvuChunk_Theory(DjvuJsonDocument doc, int index)
{
int pageCount = 0;
using (DjvuDocument document = DjvuNet.Tests.Util.GetTestDocument(index, out pageCount))
{
DjvuNet.Tests.Util.VerifyDjvuDocument(pageCount, document);
DjvuNet.Tests.Util.VerifyDjvuDocumentCtor(pageCount, document);
if (pageCount <= 1)
{
Assert.IsNotType <DjvmChunk>(document.RootForm);
Assert.IsType <DjvuChunk>(document.RootForm);
DjvuChunk djvu = document.RootForm as DjvuChunk;
Assert.NotNull(djvu);
Assert.NotNull(djvu.Info);
// TODO - Json deserialization is not supporting single page docs
// data are sliced to fit into other format - need to fix
}
else
{
Assert.IsType <DjvmChunk>(document.RootForm);
DjvmChunk djvm = document.RootForm as DjvmChunk;
Assert.NotNull(djvm);
Assert.NotNull(djvm.Pages);
Assert.True(djvm.Pages.Count > 1);
}
}
}
public Bookmark(DjvuReader reader, DjvuDocument document, Bookmark parent)
{
_document = document;
_parent = parent;
DecodeBookmarkData(reader);
LoadReferencedPage();
}
public PageViewControlState(DjvuDocument document, uint pageNumber, double width, double height, PageViewObserver zoomFactorObserver)
{
Document = document;
PageNumber = pageNumber;
Width = width;
Height = height;
ZoomFactorObserver = zoomFactorObserver;
}
public void IsDjvuDocument_Stream005()
{
using (MemoryStream stream = new MemoryStream(new byte[4]))
{
Assert.Equal(4, stream.Length);
Assert.False(DjvuDocument.IsDjvuDocument(stream));
}
}
public void IsDjvuDocument_Stream006()
{
using (MemoryStream stream = new MemoryStream(DjvuDocument.MagicBuffer))
{
Assert.Equal(8, stream.Length);
Assert.False(DjvuDocument.IsDjvuDocument(stream));
}
}
public Bookmark(DjvuReader reader, DjvuDocument document, Bookmark parent)
{
_document = document;
_parent = parent;
DecodeBookmarkData(reader);
LoadReferencedPage();
}
public void ctor002()
{
int pageCount = Util.GetTestDocumentPageCount(2);
using (DjvuDocument document = Util.GetTestDocument(2, out pageCount))
{
Util.VerifyDjvuDocumentCtor(pageCount, document);
}
}
public static void VerifyDjvuDocument(int pageCount, DjvuDocument document)
{
Assert.NotNull(document.FirstPage);
Assert.NotNull(document.LastPage);
if (pageCount > 0)
{
Assert.Equal <int>(pageCount, document.Pages.Count);
}
}
public void ctor030()
{
int pageCount = Util.GetTestDocumentPageCount(30);
using (DjvuDocument document = new DjvuDocument(Path.Combine(Util.ArtifactsPath, "test030C.djvu")))
{
Util.VerifyDjvuDocumentCtor(pageCount, document);
}
}
public void IsDjvuDocument_String006()
{
string errorPath = Path.GetTempFileName();
using (FileStream stream = new FileStream(errorPath, FileMode.Open, FileAccess.Read, FileShare.None))
{
Assert.Throws <DjvuAggregateException>(() => DjvuDocument.IsDjvuDocument(errorPath));
}
}
public Bookmark(DjvuDocument document, Bookmark parent, string name, string url, Bookmark[] children)
{
_document = document;
_parent = parent;
_name = name;
_uRL = url;
_children = children;
LoadReferencedPage();
}
public Bookmark(DjvuDocument document, Bookmark parent, string name, string url, Bookmark[] children)
{
_document = document;
_parent = parent;
_name = name;
_uRL = url;
_children = children;
LoadReferencedPage();
}
public void DirectoryTest001()
{
int pageCount;
using (DjvuDocument doc = Util.GetTestDocument(30, out pageCount))
{
Assert.Null(doc.Directory);
Assert.IsType <DjvuChunk>(doc.RootForm);
}
}
public void IsLegalCompundTest001()
{
string file = Path.Combine(Util.ArtifactsPath, "test078C.djvu");
using (DjvuDocument doc = new DjvuDocument(file))
{
var page = (DjvuPage)doc.Pages[0];
Assert.False(page.IsLegalCompound());
}
}
public void CheckDjvuHeader002()
{
byte[] buffer = new byte[] { 0x41, 0x54, 0x26, 0x54, 0x46, 0x4f, 0x52, 0x4d };
using (MemoryStream stream = new MemoryStream(buffer))
using (DjvuReader reader = new DjvuReader(stream))
{
DjvuDocument doc = new DjvuDocument();
doc.CheckDjvuHeader(reader);
}
}
public void IsDjvuDocument_Stream007()
{
byte[] buffer = new byte[] { 0x41, 0x54, 0x26, 0x54, 0x46, 0x4f, 0x52, 0x4d, 0x41, 0x54, 0x26, 0x54, 0x46, 0x4f, 0x52, 0x4d };
using (MemoryStream stream = new MemoryStream(buffer))
{
Assert.Equal(16, stream.Length);
stream.Position = 10;
Assert.True(DjvuDocument.IsDjvuDocument(stream));
}
}
public void CheckDjvuHeader001()
{
byte[] buffer = new byte[] { 0x01, 0x07, 0x31, 0x67, 0xdf, 0xe4, 0x5f, 0x61 };
using (MemoryStream stream = new MemoryStream(buffer))
using (DjvuReader reader = new DjvuReader(stream))
{
DjvuDocument doc = new DjvuDocument();
Assert.Throws <DjvuFormatException>(() => doc.CheckDjvuHeader(reader));
}
}
public void GetRootFormChildren001()
{
int pageCount = 0;
using (DjvuDocument doc = Util.GetTestDocument(30, out pageCount))
{
DjvuChunk form = doc.GetRootFormChildren <DjvuChunk>().FirstOrDefault();
Assert.NotNull(form);
Assert.IsType <DjvuChunk>(form);
}
}
public void LoadTest039()
{
string file = Util.GetTestFilePath(39);
using (DjvuDocument document = new DjvuDocument())
{
int hash = file.GetHashCode();
document.Load(file, hash);
Assert.Equal(hash, document.Identifier);
}
}
public void IsDjvuDocument_Stream003()
{
byte[] buffer = DjvuDocument.MagicBuffer;
byte[] target = new byte[buffer.Length * 3];
Buffer.BlockCopy(buffer, 0, target, 0, buffer.Length);
using (MemoryStream stream = new MemoryStream(target))
{
bool result = DjvuDocument.IsDjvuDocument(stream);
Assert.True(result);
}
}
private void BuildNavigation(DjvuDocument document)
{
List<Bookmark> bookmarks = new List<Bookmark>();
for (int x = 0; x < document.Pages.Length; x++)
{
DjvuPage page = document.Pages[x];
int pageNum = x + 1;
bookmarks.Add(new Bookmark(document, null, string.Format("Page {0}", pageNum), string.Format("#{0}", pageNum), new Bookmark[0]));
}
_bookmarks = bookmarks.ToArray();
}
public static void Main(string[] args)
{
DjvuDocument doc = new DjvuDocument(@"Mcguffey's_Primer.djvu");
var page = doc.Pages[0];
page
.BuildPageImage()
.Save("TestImage1.png", ImageFormat.Png);
page.IsInverted = true;
page
.BuildPageImage()
.Save("TestImage2.png", ImageFormat.Png);
}
public AnnotationChunk(DjvuReader reader, IFFChunk parent, DjvuDocument document)
: base(reader, parent, document)
{
}
public DocumentNavigator(DjvuDocument document)
{
BuildNavigation(document);
}
public DjvuPage(int pageNumber, DjvuDocument document, DirmComponent header, TH44Chunk thumbnail, DjviChunk[] includedItems, FormChunk form)
{
PageNumber = pageNumber;
Document = document;
Header = header;
Thumbnail = thumbnail;
IncludedItems = includedItems;
PageForm = form;
}
public FormChunk(DjvuReader reader, IFFChunk parent, DjvuDocument document)
: base(reader, parent, document)
{
// Nothing
}
public ThumChunk(DjvuReader reader, IFFChunk parent, DjvuDocument document)
: base(reader, parent, document)
{
}
