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));
}
public GPixmap GetPixelMap(GRect rect, int subsample, double gamma, GPixmap retval)
{
Verify.SubsampleRange(subsample);
if (rect?.Empty != false)
{
return((retval == null) ? (new PixelMap()) : retval.Init(0, 0, null));
}
GPixmap bg = GetBgPixmap(rect, subsample, gamma, retval);
if (ForegroundJB2Image != null)
{
if (bg == null)
{
bg = (retval == null) ? new PixelMap() : retval;
bg.Init(rect.Height, rect.Width, _IsInverted ? Pixel.BlackPixel : Pixel.WhitePixel);
}
if (Stencil(bg, rect, subsample, gamma))
{
retval = bg;
}
}
else
{
retval = bg;
}
return(retval);
}
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;
}