internal DjvuNet.Graphics.Map GetForegroundMap()
{
lock (LoadingLock)
{
DjvuNet.Graphics.Map result = null;
JB2Image jb2image = null;
IInterWavePixelMap iwPixelMap = _Page.ForegroundIWPixelMap;
if (iwPixelMap != null)
{
result = _Page.ForegroundIWPixelMap.GetPixelMap();
}
else if ((jb2image = _Page.ForegroundJB2Image) != null)
{
if (_Page.ForegroundPalette == null)
{
result = jb2image.GetBitmap(1, GBitmap.BorderSize);
}
else
{
result = jb2image.GetPixelMap(_Page.ForegroundPalette, 1, 16);
}
}
else if (iwPixelMap == null && jb2image == null)
{
result = new GBitmap(_Page.Height, _Page.Width, GBitmap.BorderSize);
}
return(result);
}
}
internal bool IsLegalCompound()
{
int width = Width;
int height = Height;
if (width <= 0 || height <= 0)
return false;
JB2Image fgJb2 = ForegroundJB2Image;
if (fgJb2 == null || fgJb2.Width != width || fgJb2.Height != height)
return false;
// There is no need to synchronize since we won't access data which could be updated.
IInterWavePixelMap bgIWPixmap = (IInterWavePixelMap)BackgroundIWPixelMap;
int bgred = 0;
if (bgIWPixmap != null)
bgred = ComputeRed(width, height, bgIWPixmap.Width, bgIWPixmap.Height);
if ((bgred < 1) || (bgred > 12))
return false;
int fgred = 0;
if (ForegroundIWPixelMap != null)
{
GPixmap fgPixmap = ForegroundPixelMap;
fgred = ComputeRed(width, height, fgPixmap.Width, fgPixmap.Height);
}
return ((fgred >= 1) && (fgred <= 12));
}
/// <summary>
/// Gets the foreground image for the page
/// </summary>
/// <param name="resizeToPage"></param>
/// <returns></returns>
internal System.Drawing.Bitmap GetForegroundImage(int subsample, bool resizeImage = false)
{
Verify.SubsampleRange(subsample);
lock (LoadingLock)
{
Bitmap result = null;
JB2Image jb2image = null;
IInterWavePixelMap iwPixelMap = _Page.ForegroundIWPixelMap;
if (iwPixelMap != null)
{
result = _Page.ForegroundIWPixelMap.GetPixelMap().ToImage();
}
else if ((jb2image = _Page.ForegroundJB2Image) != null)
{
if (_Page.ForegroundPalette == null)
{
result = jb2image.GetBitmap(1, GBitmap.BorderSize).ToImage();
}
else
{
result = jb2image.GetPixelMap(_Page.ForegroundPalette, 1, 16).ToImage();
}
}
else if (iwPixelMap == null && jb2image == null)
{
result = CreateBlankImage(Brushes.Black, _Page.Width / subsample, _Page.Height / subsample);
}
return(resizeImage ? ResizeImage(result, _Page.Width / subsample, _Page.Height / subsample) : result);
}
}
/// <summary>
/// Gets the foreground image for the page.
/// </summary>
/// <param name="resizeToPage"></param>
/// <returns></returns>
public static Bitmap GetForegroundImage(this DjvuImage image, int subsample, bool resizeImage = false)
{
Verify.SubsampleRange(subsample);
lock (image.LoadingLock)
{
Bitmap result = null;
JB2Image jb2image = null;
IInterWavePixelMap iwPixelMap = image.Page.ForegroundIWPixelMap;
if (iwPixelMap != null)
{
result = image.Page.ForegroundIWPixelMap.GetPixelMap().ToImage();
}
else if ((jb2image = image.Page.ForegroundJB2Image) != null)
{
if (image.Page.ForegroundPalette == null)
{
result = jb2image.GetBitmap(1, GBitmap.BorderSize).ToImage();
}
else
{
result = jb2image.GetPixelMap(image.Page.ForegroundPalette, 1, 16).ToImage();
}
}
else if (iwPixelMap == null && jb2image == null)
{
result = CreateBlankImage(Brushes.Black, image.Page.Width / subsample, image.Page.Height / subsample);
}
return(resizeImage ? ResizeImage(result, image.Page.Width / subsample, image.Page.Height / subsample) : result);
}
}
/// <summary>
/// Progressively decodes the background image
/// </summary>
/// <param name="pixelMap"></param>
public IInterWavePixelMap ProgressiveDecodeBackground(IInterWavePixelMap pixelMap)
{
using (IDjvuReader reader = Reader.CloneReaderToMemory(DataOffset, Length))
{
pixelMap.Decode(reader);
}
return(pixelMap);
}
public void DecodeImageTest()
{
string file = Path.Combine(Util.ArtifactsDataPath, "test001C_P01.fg44");
using (FileStream stream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read))
using (DjvuReader reader = new DjvuReader(stream))
{
BM44Chunk unk = new BM44Chunk(reader, null, null, null, reader.Length);
Assert.Equal <ChunkType>(ChunkType.BM44, unk.ChunkType);
Assert.Equal(ChunkType.BM44.ToString(), unk.Name);
Assert.Equal <long>(0, unk.DataOffset);
Assert.Equal <long>(reader.Length, unk.Length);
IInterWavePixelMap map = unk.DecodeImage();
Assert.NotNull(map);
}
}
public void ImageTest035()
{
string file = Path.Combine(Util.ArtifactsDataPath, "test035C_P01_0.bg44");
using (FileStream fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
using (IDjvuReader reader = new DjvuReader(fs))
{
BG44Chunk unk = new BG44Chunk(reader, null, null, "BG44", fs.Length);
unk.Initialize();
var map = new InterWavePixelMapDecoder();
IInterWavePixelMap result = unk.BackgroundImage;
var pixMap = result.GetPixelMap();
unk.BackgroundImage = map;
Assert.NotSame(result, unk.BackgroundImage);
Assert.Same(map, unk.BackgroundImage);
}
}
public void ProgressiveDecodeBackgroundTest()
{
string file = Path.Combine(Util.ArtifactsDataPath, "test001C_P01.fg44");
using (FileStream stream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read))
using (DjvuReader reader = new DjvuReader(stream))
{
PM44Chunk unk = new PM44Chunk(reader, null, null, null, reader.Length);
Assert.Equal <ChunkType>(ChunkType.PM44, unk.ChunkType);
Assert.Equal(ChunkType.PM44.ToString(), unk.Name);
Assert.Equal <long>(0, unk.DataOffset);
Assert.Equal <long>(reader.Length, unk.Length);
var map = new InterWavePixelMapDecoder();
IInterWavePixelMap result = unk.ProgressiveDecodeBackground(map);
Assert.NotNull(map);
}
}
internal bool Stencil(IPixelMap pm, Graphics.Rectangle rect, int subsample, double gamma)
{
Verify.SubsampleRange(subsample);
int width = Width;
int height = Height;
if (width <= 0 || height <= 0)
return false;
double gammaCorr = 1.0D;
if (gamma > 0.0D)
{
gammaCorr = gamma / Gamma;
}
if (gammaCorr < 0.10000000000000001D)
{
gammaCorr = 0.10000000000000001D;
}
else if (gammaCorr > 10D)
{
gammaCorr = 10D;
}
JB2Image fgJb2 = ForegroundJB2Image;
if (fgJb2 != null)
{
ColorPalette fgPalette = ForegroundPalette;
if (fgPalette != null)
{
List<int> components = new List<int>();
GBitmap bm = GetBitmapList(rect, subsample, 1, components);
if (fgJb2.Blits.Count != fgPalette.BlitColors?.Length)
{
pm.Attenuate(bm, 0, 0);
return false;
}
GPixmap colors =
new PixelMap().Init(1, fgPalette.PaletteColors.Length, null);
GPixelReference color = colors.CreateGPixelReference(0);
for (int i = 0; i < colors.Width; color.IncOffset())
fgPalette.IndexToColor(i++, color);
colors.ApplyGammaCorrection(gammaCorr);
List<int> compset = new List<int>();
while (components.Count > 0)
{
int lastx = 0;
int colorindex = fgPalette.BlitColors[components[0]];
GRect comprect = new GRect();
compset = new List<int>();
for (int pos = 0; pos < components.Count; )
{
int blitno = ((int)components[pos]);
JB2Blit pblit = fgJb2.Blits[blitno];
if (pblit.Left < lastx)
{
break;
}
lastx = pblit.Left;
if (fgPalette.BlitColors[blitno] == colorindex)
{
JB2Shape pshape = fgJb2.GetShape(pblit.ShapeNumber);
GRect xrect = new GRect(pblit.Left, pblit.Bottom,
pshape.Bitmap.Width, pshape.Bitmap.Height);
comprect.Recthull(comprect, xrect);
compset.Add(components[pos]);
components.RemoveAt(pos);
}
else
{
pos++;
}
}
comprect.XMin /= subsample;
comprect.YMin /= subsample;
comprect.XMax = ((comprect.XMax + subsample) - 1) / subsample;
comprect.YMax = ((comprect.YMax + subsample) - 1) / subsample;
comprect.Intersect(comprect, rect);
if (comprect.Empty)
{
continue;
}
bm = new DjvuNet.Graphics.Bitmap();
bm.Init(comprect.Height, comprect.Width, 0);
bm.Grays = 1 + (subsample * subsample);
int rxmin = comprect.XMin * subsample;
int rymin = comprect.YMin * subsample;
for (int pos = 0; pos < compset.Count; ++pos)
{
int blitno = ((int)compset[pos]);
JB2Blit pblit = fgJb2.Blits[blitno];
JB2Shape pshape = fgJb2.GetShape(pblit.ShapeNumber);
bm.Blit(
pshape.Bitmap,
pblit.Left - rxmin,
pblit.Bottom - rymin,
subsample);
}
color.SetOffset(colorindex);
pm.Blit(
bm,
comprect.XMin - rect.XMin,
comprect.YMin - rect.YMin,
color);
}
return true;
}
// Three layer model.
IInterWavePixelMap fgIWPixmap = ForegroundIWPixelMap;
if (fgIWPixmap != null)
{
GBitmap bm = GetBitmap(rect, subsample, 1, null);
if (bm != null && pm != null)
{
GPixmap fgPixmap = ForegroundPixelMap;
int w = fgPixmap.Width;
int h = fgPixmap.Height;
int red = ComputeRed(width, height, w, h);
// if((red < 1) || (red > 12))
if (red < 1 || red > 16)
return false;
//
// int supersample = (red <= subsample)
// ? 1
// : (red / subsample);
// int wantedred = supersample * subsample;
//
// if(red == wantedred)
// {
// pm.stencil(bm, fgPixmap, supersample, rect, gamma_correction);
//
// return 1;
// }
pm.Stencil(bm, fgPixmap, red, subsample, rect, gammaCorr);
return true;
}
}
}
return false;
}
/// <summary>
/// Gets the background pixmap
/// </summary>
/// <param name="rect"></param>
/// <param name="subSample"></param>
/// <param name="gamma"></param>
/// <param name="retval"></param>
/// <returns></returns>
public GPixmap GetBgPixmap(GRect rect, int subsample, double gamma, GPixmap retval)
{
Verify.SubsampleRange(subsample);
GPixmap pMap = null;
int width = Width;
int height = Height;
if (width <= 0 || height <= 0)
return null;
double gammaCorr = 1.0D;
if (gamma > 0.0D && Gamma > 0)
{
gammaCorr = gamma / Gamma;
}
if (gammaCorr < 0.10000000000000001D)
{
gammaCorr = 0.10000000000000001D;
}
else if (gammaCorr > 10D)
{
gammaCorr = 10D;
}
IInterWavePixelMap bgIWPixmap = BackgroundIWPixelMap;
if (bgIWPixmap != null)
{
int iwWidth = bgIWPixmap.Width;
int iwHeight = bgIWPixmap.Height;
if (iwWidth == 0 || iwHeight == 0)
return null;
int red = ComputeRed(width, height, iwWidth, iwHeight);
if (red < 1 || red > 12)
return null;
if (subsample == red)
{
pMap = bgIWPixmap.GetPixelMap(1, rect, retval);
}
else if (subsample == (2 * red))
{
pMap = bgIWPixmap.GetPixelMap(2, rect, retval);
}
else if (subsample == (4 * red))
{
pMap = bgIWPixmap.GetPixelMap(4, rect, retval);
}
else if (subsample == (8 * red))
{
pMap = bgIWPixmap.GetPixelMap(8, rect, retval);
}
else if ((red * 4) == (subsample * 3))
{
GRect xrect = new GRect();
xrect.Right = (int)Math.Floor(rect.Right * 4D / 3D);
xrect.Bottom = (int)Math.Floor(rect.Bottom * 4D / 3D);
xrect.Left = (int)Math.Ceiling((double)rect.Left * 4D / 3D);
xrect.Top = (int)Math.Ceiling((double)rect.Top * 4D / 3D);
GRect nrect = new GRect(0, 0, rect.Width, rect.Height);
if (xrect.Left > iwWidth)
xrect.Left = iwWidth;
if (xrect.Top > iwHeight)
xrect.Top = iwHeight;
GPixmap iwPMap = bgIWPixmap.GetPixelMap(1, xrect, null);
pMap = (retval != null) ? retval : new PixelMap();
pMap.Downsample43(iwPMap, nrect);
}
else
{
int po2 = 16;
while (po2 > 1 && subsample < po2 * red)
po2 >>= 1;
int inw = ((iwWidth + po2) - 1) / po2;
int inh = ((iwHeight + po2) - 1) / po2;
int outw = ((width + subsample) - 1) / subsample;
int outh = ((height + subsample) - 1) / subsample;
PixelMapScaler mapScaler = new PixelMapScaler(inw, inh, outw, outh);
mapScaler.SetHorzRatio(red * po2, subsample);
mapScaler.SetVertRatio(red * po2, subsample);
GRect xrect = mapScaler.GetRequiredRect(rect);
GPixmap iwPMap = bgIWPixmap.GetPixelMap(po2, xrect, null);
pMap = (retval != null) ? retval : new PixelMap();
mapScaler.Scale(xrect, iwPMap, rect, pMap);
}
if (pMap != null && gammaCorr != 1.0D)
{
pMap.ApplyGammaCorrection(gammaCorr);
for (int i = 0; i < 9; i++)
pMap.ApplyGammaCorrection(gammaCorr);
}
return pMap;
}
else
return null;
}
