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);
}
public GMap GetMap(GRect segment, int subsample, GMap retval)
{
Verify.SubsampleRange(subsample);
if (IsColor)
retval = GetPixelMap(segment, subsample, 0.0D,
(retval is GPixmap) ? (GPixmap)retval : null);
else
retval = GetBitmap(segment, subsample, 1,
(retval is GBitmap) ? (GBitmap)retval : null);
return retval;
}
public GBitmap GetBitmapList(GRect rect, int subsample, int align, List<int> components)
{
Verify.SubsampleRange(subsample);
if (rect.Empty)
return new Graphics.Bitmap();
int width = Width;
int height = Height;
JB2Image fgJb2 = ForegroundJB2Image;
if (width != 0 && height != 0 && fgJb2 != null && fgJb2.Width == width && fgJb2.Height == height)
return fgJb2.GetBitmap(rect, subsample, align, 0, components);
return null;
}
public Map GetMap(GRect segment, int subsample, GMap retval)
{
retval =
IsColor
? (GMap)GetPixelMap(
segment,
subsample,
0.0D,
(retval is GPixmap)
? (GPixmap)retval
: null)
: (GMap)GetBitmap(
segment,
subsample,
1,
((retval is GBitmap)
? (GBitmap)retval
: null));
return retval;
}
public GBitmap GetBitmapList(GRect rect, int subsample, int align, List<int> components)
{
if (rect.Empty)
{
return new Graphics.Bitmap();
}
if (Info != null)
{
int width = Info.Width;
int height = Info.Height;
JB2Image fgJb2 = ForegroundJB2Image;
if (
(width != 0)
&& (height != 0)
&& (fgJb2 != null)
&& (fgJb2.Width == width)
&& (fgJb2.Height == height))
{
return fgJb2.GetBitmap(rect, subsample, align, 0, components);
}
}
return null;
}
public virtual Graphics.PixelMap GetPixmap(int subsample, Rectangle rect, Graphics.PixelMap retval)
{
if (_ymap == null)
{
return null;
}
if (retval == null)
{
retval = new Graphics.PixelMap();
}
int w = rect.Width;
int h = rect.Height;
int pixsep = 3;
int rowsep = w * pixsep;
sbyte[] bytes = retval.Init(h, w, null).Data;
_ymap.Image(subsample, rect, 0, bytes, rowsep, pixsep, false);
if ((_crmap != null) && (_cbmap != null) && (_crcbDelay >= 0))
{
_cbmap.Image(subsample, rect, 1, bytes, rowsep, pixsep, _crcbHalf);
_crmap.Image(subsample, rect, 2, bytes, rowsep, pixsep, _crcbHalf);
}
PixelReference pixel = retval.CreateGPixelReference(0);
for (int i = 0; i < h; )
{
pixel.SetOffset(i++, 0);
if ((_crmap != null) && (_cbmap != null) && (_crcbDelay >= 0))
{
pixel.YCC_to_RGB(w);
}
else
{
for (int x = w; x-- > 0; pixel.IncOffset())
{
pixel.SetGray((sbyte)(127 - pixel.Blue));
}
}
}
return retval;
}
public GBitmap GetBitmap(GRect rect, int subsample, int align, GBitmap retval)
{
Verify.SubsampleRange(subsample);
return GetBitmapList(rect, 1, 1, null);
}
public Rectangle CreateRectangles(Rectangle desired, Rectangle red)
{
Rectangle inp = new Rectangle();
// Parameter validation
if (
(desired.XMin < 0)
|| (desired.YMin < 0)
|| (desired.XMax > destWidth)
|| (desired.YMax > destHeight))
{
throw new Exception(
"desired rectangle too big: " + desired.XMin + "," + desired.YMin
+ "," + desired.XMax + "," + desired.YMax + "," + destWidth + ","
+ destHeight);
}
// Compute ratio (if not done yet)
if (vcoord == null)
{
SetVertRatio(0, 0);
}
if (hcoord == null)
{
SetHorzRatio(0, 0);
}
// Compute reduced bounds
red.XMin = (hcoord[desired.XMin]) >> FRACBITS;
red.YMin = (vcoord[desired.YMin]) >> FRACBITS;
red.XMax = ((hcoord[desired.XMax - 1] + FRACSIZE) - 1) >> FRACBITS;
red.YMax = ((vcoord[desired.YMax - 1] + FRACSIZE) - 1) >> FRACBITS;
// Borders
red.XMin = (red.XMin > 0)
? red.XMin
: 0;
red.XMax = (red.XMax < redw)
? (red.XMax + 1)
: redw;
red.YMin = (red.YMin > 0)
? red.YMin
: 0;
red.YMax = (red.YMax < redh)
? (red.YMax + 1)
: redh;
// Input
inp.XMin = red.XMin << xshift;
if (inp.XMin < 0)
{
inp.XMin = 0;
}
inp.XMax = red.XMax << xshift;
if (inp.XMax > srcWidth)
{
inp.XMax = srcWidth;
}
inp.YMin = red.YMin << yshift;
if (inp.YMin < 0)
{
inp.YMin = 0;
}
inp.YMax = red.YMax << yshift;
if (inp.YMax > srcHeight)
{
inp.YMax = srcHeight;
}
return inp;
}
public void Scale(Rectangle provided_input, PixelMap sourceMap, Rectangle targetRect, PixelMap output)
{
// Compute rectangles
Rectangle required_red = new Rectangle();
Rectangle sourceRect = CreateRectangles(targetRect, required_red);
// Parameter validation
if (
(provided_input.Width != sourceMap.ImageWidth)
|| (provided_input.Height != sourceMap.ImageHeight))
{
throw new Exception("invalid rectangle");
}
if (
(provided_input.XMin > sourceRect.XMin)
|| (provided_input.YMin > sourceRect.YMin)
|| (provided_input.XMax < sourceRect.XMax)
|| (provided_input.YMax < sourceRect.YMax))
{
throw new Exception("invalid rectangle");
}
// Adjust output pixmap
if (
(targetRect.Width != (int)output.ImageWidth)
|| (targetRect.Height != (int)output.ImageHeight))
{
output.Init(
targetRect.Height,
targetRect.Width,
null);
}
// Prepare temp stuff
int bufw = required_red.Width;
Pixel[] lbuffer = new Pixel[bufw + 2];
for (int i = 0; i < lbuffer.Length; )
{
lbuffer[i++] = new Pixel();
}
try
{
if ((xshift > 0) || (yshift > 0))
{
p1 = new PixelMap().Init(1, bufw, null);
p2 = new PixelMap().Init(2, bufw, null);
l1 = l2 = -1;
}
// Loop on output lines
for (int y = targetRect.YMin; y < targetRect.YMax; y++)
{
// Perform vertical interpolation
{
int fy = vcoord[y];
int fy1 = fy >> FRACBITS;
int fy2 = fy1 + 1;
PixelReference upper;
PixelReference lower;
// Obtain upper and lower line in reduced image
if ((xshift > 0) || (yshift > 0))
{
lower = GetLine(fy1, required_red, provided_input, sourceMap);
upper = GetLine(fy2, required_red, provided_input, sourceMap);
}
else
{
int dx = required_red.XMin - provided_input.XMin;
if (required_red.YMin > fy1)
{
fy1 = required_red.YMin;
}
if (required_red.YMax <= fy2)
{
fy2 = required_red.YMax - 1;
}
lower =
sourceMap.CreateGPixelReference(fy1 - provided_input.YMin, dx);
upper =
sourceMap.CreateGPixelReference(fy2 - provided_input.YMin, dx);
}
// Compute line
int idest = 1;
short[] deltas = interp[fy & FRACMASK];
for (
int edest = idest + bufw;
idest < edest;
upper.IncOffset(), lower.IncOffset())
{
Pixel dest = lbuffer[idest++];
int lower_r = lower.Red;
int delta_r = deltas[(256 + upper.Red) - lower_r];
int lower_g = lower.Green;
int delta_g = deltas[(256 + upper.Green) - lower_g];
int lower_b = lower.Blue;
int delta_b = deltas[(256 + upper.Blue) - lower_b];
dest.SetBGR(lower_b + delta_b, lower_g + delta_g, lower_r + delta_r);
}
}
// Perform horizontal interpolation
{
// Prepare for side effects
lbuffer[0] = lbuffer[1];
// lbuffer[bufw] = lbuffer[bufw];
int line = 1 - required_red.XMin;
PixelReference dest =
output.CreateGPixelReference(y - targetRect.YMin, 0);
// Loop horizontally
for (int x = targetRect.XMin; x < targetRect.XMax; x++)
{
int n = hcoord[x];
int lower = line + (n >> FRACBITS);
Pixel lower0 = lbuffer[lower];
Pixel lower1 = lbuffer[lower + 1];
short[] deltas = interp[n & FRACMASK];
int lower_r = lower0.Red;
int delta_r = deltas[(256 + lower1.Red) - lower_r];
int lower_g = lower0.Green;
int delta_g = deltas[(256 + lower1.Green) - lower_g];
int lower_b = lower0.Blue;
int delta_b = deltas[(256 + lower1.Blue) - lower_b];
dest.SetBGR(lower_b + delta_b, lower_g + delta_g, lower_r + delta_r);
dest.IncOffset();
}
}
}
}
finally
{
p1 = null;
p2 = null;
}
}
public Bitmap GetBitmap(Rectangle rect, int subsample, int align)
{
return GetBitmap(rect, subsample, align, 0);
}
public Bitmap GetBitmap(Rectangle rect, int subsample)
{
return GetBitmap(rect, subsample, 1);
}
public Bitmap GetBitmap(Rectangle rect)
{
return GetBitmap(rect, 1);
}
/// <summary>
/// Set this rectangle as the union of two rectangles.
/// </summary>
/// <param name="rect1">rectangle to union
/// </param>
/// <param name="rect2">rectangle to union
///
/// </param>
/// <returns> true if the results are non-empty
/// </returns>
public virtual bool Recthull(Rectangle rect1, Rectangle rect2)
{
if (rect1.Empty)
{
Right = rect2.Right;
Left = rect2.Left;
Bottom = rect2.Bottom;
Top = rect2.Top;
return !Empty;
}
if (rect2.Empty)
{
Right = rect1.Right;
Left = rect1.Left;
Bottom = rect1.Bottom;
Top = rect1.Top;
return !Empty;
}
Right = Math.Min(rect1.Right, rect2.Right);
Left = Math.Max(rect1.Left, rect2.Left);
Bottom = Math.Min(rect1.Bottom, rect2.Bottom);
Top = Math.Max(rect1.Top, rect2.Top);
return true;
}
/// <summary> Set this rectangle as the intersection of two rectangles.
///
/// </summary>
/// <param name="rect1">rectangle to intersect
/// </param>
/// <param name="rect2">rectangle to intersect
///
/// </param>
/// <returns> true if the intersection is not empty
/// </returns>
public virtual bool Intersect(Rectangle rect1, Rectangle rect2)
{
Right = Math.Max(rect1.Right, rect2.Right);
Left = Math.Min(rect1.Left, rect2.Left);
Bottom = Math.Max(rect1.Bottom, rect2.Bottom);
Top = Math.Min(rect1.Top, rect2.Top);
if (Empty)
{
Right = Bottom = Left = Top = 0;
return false;
}
return true;
}
/// <summary> Test if a rectangle is contained within this rectangle.
///
/// </summary>
/// <param name="rect">rectangle to test
///
/// </param>
/// <returns> true if the rectangle is contained
/// </returns>
public virtual bool Contains(Rectangle rect)
{
return rect.Empty || (Contains(rect.Right, rect.Bottom) && Contains(rect.Left - 1, rect.Top - 1));
}
public GPixmap GetPixelMap(GRect rect, int subsample, double gamma, PixelMap retval)
{
if (rect.Empty)
{
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, GPixel.WhitePixel);
}
if (Stencil(bg, rect, subsample, gamma))
{
retval = bg;
}
}
else
{
retval = bg;
}
return retval;
}
public Rectangle GetRequiredRect(Rectangle targetRect)
{
Rectangle red = new Rectangle();
return CreateRectangles(targetRect, red);
}
public Bitmap GetBitmap(Rectangle rect, int subsample, int align, int dispy, List<int> components)
{
if (components == null)
{
return GetBitmap(rect, subsample, align, dispy);
}
if ((Width == 0) || (Height == 0))
{
throw new SystemException("Image can not create bitmap");
}
int rxmin = rect.Right * subsample;
int rymin = rect.Bottom * subsample;
int swidth = rect.Width;
int sheight = rect.Height;
int border = (((swidth + align) - 1) & ~(align - 1)) - swidth;
Bitmap bm = new Bitmap();
bm.Init(sheight, swidth, border);
bm.Grays = (1 + (subsample * subsample));
for (int blitno = 0; blitno < Blits.Count; )
{
JB2Blit pblit = GetBlit(blitno++);
JB2Shape pshape = GetShape(pblit.ShapeNumber);
if (pshape.Bitmap != null)
{
if (bm.Blit(pshape.Bitmap, pblit.Left - rxmin, (dispy + pblit.Bottom) - rymin, subsample))
{
components.Add((blitno - 1));
}
}
}
return bm;
}
private PixelReference GetLine(int fy, Rectangle required_red, Rectangle provided_input, PixelMap input)
{
if (fy < required_red.YMin)
{
fy = required_red.YMin;
}
else if (fy >= required_red.YMax)
{
fy = required_red.YMax - 1;
}
// Cached line
if (fy == l2)
{
return p2.CreateGPixelReference(0);
}
if (fy == l1)
{
return p1.CreateGPixelReference(0);
}
// Shift
PixelMap p = p1;
p1 = p2;
l1 = l2;
p2 = p;
l2 = fy;
// Compute location of line
Rectangle line = new Rectangle();
line.XMin = required_red.XMin << xshift;
line.XMax = required_red.XMax << xshift;
line.YMin = fy << yshift;
line.YMax = (fy + 1) << yshift;
line.Intersect(line, provided_input);
line.Translate(-provided_input.XMin, -provided_input.YMin);
// Prepare variables
int botline = input.RowOffset(line.YMin);
int rowsize = input.GetRowSize();
int sw = 1 << xshift;
int div = xshift + yshift;
int rnd = 1 << (div - 1);
int rnd2 = rnd + rnd;
PixelReference inp1 = input.CreateGPixelReference(0);
PixelReference ip = p.CreateGPixelReference(0);
// Compute averages
for (int x = line.XMin; x < line.XMax; x += sw, ip.IncOffset())
{
int r = 0;
int g = 0;
int b = 0;
int s = 0;
int inp0 = botline + x;
int sy2 = line.Height;
int sy1 = (1 << yshift);
if (sy1 > sy2)
{
sy1 = sy2;
}
for (int sy = 0; sy < sy1; sy++, inp0 += rowsize)
{
int sx1 = x + sw;
inp1.SetOffset(inp0);
if (sx1 > line.XMax)
{
sx1 = line.XMax;
}
for (int sx = sx1 - x; sx-- > 0; s++, inp1.IncOffset())
{
r += inp1.Red;
g += inp1.Green;
b += inp1.Blue;
}
}
if (s == rnd2)
{
ip.SetBGR((b + rnd) >> div, (g + r) >> div, (r + rnd) >> div);
}
else
{
ip.SetBGR((b + (s / 2)) / 2, (g + (s / 2)) / s, (r + (s / 2)) / s);
}
}
// Return
return p2.CreateGPixelReference(0);
}
public void Image(int subsample, Rectangle rect, int index, sbyte[] img8, int rowsize, int pixsep, bool fast)
{
int nlevel = 0;
while ((nlevel < 5) && ((32 >> nlevel) > subsample))
{
nlevel++;
}
int boxsize = 1 << nlevel;
if (subsample != (32 >> nlevel))
{
throw new ArgumentException("(Map::image) Unsupported subsampling factor");
}
if (rect.Empty)
{
throw new ArgumentException("(Map::image) Rectangle is empty");
}
Rectangle irect = new Rectangle(0, 0, ((Iw + subsample) - 1) / subsample, ((Ih + subsample) - 1) / subsample);
if ((rect.Right < 0) || (rect.Bottom < 0) || (rect.Left > irect.Left) || (rect.Top > irect.Top))
{
throw new ArgumentException("(Map::image) Rectangle is out of bounds: " + rect.Right + "," + rect.Bottom +
"," + rect.Left + "," + rect.Top + "," + irect.Left + "," + irect.Top);
}
Rectangle[] needed = new Rectangle[8];
Rectangle[] recomp = new Rectangle[8];
for (int i = 0; i < 8; )
{
needed[i] = new Rectangle();
recomp[i++] = new Rectangle();
}
int r = 1;
needed[nlevel] = (Rectangle)rect.Duplicate();
recomp[nlevel] = (Rectangle)rect.Duplicate();
for (int i = nlevel - 1; i >= 0; i--)
{
needed[i] = recomp[i + 1];
needed[i].Inflate(3 * r, 3 * r);
needed[i].Intersect(needed[i], irect);
r += r;
recomp[i].Right = ((needed[i].Right + r) - 1) & ~(r - 1);
recomp[i].Left = needed[i].Left & ~(r - 1);
recomp[i].Bottom = ((needed[i].Bottom + r) - 1) & ~(r - 1);
recomp[i].Top = needed[i].Top & ~(r - 1);
}
Rectangle work = new Rectangle();
work.Right = needed[0].Right & ~(boxsize - 1);
work.Bottom = needed[0].Bottom & ~(boxsize - 1);
work.Left = ((needed[0].Left - 1) & ~(boxsize - 1)) + boxsize;
work.Top = ((needed[0].Top - 1) & ~(boxsize - 1)) + boxsize;
int dataw = work.Width;
short[] data = new short[dataw * work.Height];
int blkw = Bw >> 5;
int lblock = ((work.Bottom >> nlevel) * blkw) + (work.Right >> nlevel);
short[] liftblock = new short[1024];
for (int by = work.Bottom, ldata = 0;
by < work.Top;
by += boxsize, ldata += (dataw << nlevel), lblock += blkw)
{
for (int bx = work.Right, bidx = lblock, rdata = ldata;
bx < work.Left;
bx += boxsize, bidx++, rdata += boxsize)
{
IWBlock block = Blocks[bidx];
int mlevel = nlevel;
if ((nlevel > 2) &&
(((bx + 31) < needed[2].Right) || (bx > needed[2].Left) || ((by + 31) < needed[2].Bottom) ||
(by > needed[2].Top)))
{
mlevel = 2;
}
int bmax = ((1 << (mlevel + mlevel)) + 15) >> 4;
int ppinc = 1 << (nlevel - mlevel);
int ppmod1 = dataw << (nlevel - mlevel);
int ttmod0 = 32 >> mlevel;
int ttmod1 = ttmod0 << 5;
block.WriteLiftBlock(liftblock, 0, bmax);
for (int ii = 0, tt = 0, pp = rdata; ii < boxsize; ii += ppinc, pp += ppmod1, tt += (ttmod1 - 32))
{
for (int jj = 0; jj < boxsize; jj += ppinc, tt += ttmod0)
{
data[pp + jj] = liftblock[tt];
}
}
}
}
r = boxsize;
for (int i = 0; i < nlevel; i++)
{
Rectangle comp = needed[i];
comp.Right = comp.Right & ~(r - 1);
comp.Bottom = comp.Bottom & ~(r - 1);
comp.Translate(-work.Right, -work.Bottom);
if (fast && (i >= 4))
{
for (int ii = comp.Bottom, pp = (comp.Bottom * dataw); ii < comp.Top; ii += 2, pp += (dataw + dataw))
{
for (int jj = comp.Right; jj < comp.Left; jj += 2)
{
data[pp + jj + dataw] = data[pp + jj + dataw + 1] = data[pp + jj + 1] = data[pp + jj];
}
}
break;
}
Backward(data, (comp.Bottom * dataw) + comp.Right, comp.Width, comp.Height, dataw, r, r >> 1);
r >>= 1;
}
Rectangle nrect = (Rectangle)rect.Duplicate();
nrect.Translate(-work.Right, -work.Bottom);
for (int i = nrect.Bottom, pidx = (nrect.Bottom * dataw), ridx = index;
i++ < nrect.Top;
ridx += rowsize, pidx += dataw)
{
for (int j = nrect.Right, pixidx = ridx; j < nrect.Left; j++, pixidx += pixsep)
{
int x = (data[pidx + j] + 32) >> 6;
if (x < -128)
{
x = -128;
}
else if (x > 127)
{
x = 127;
}
img8[pixidx] = (sbyte)x;
}
}
}
/// <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;
}
private bool Stencil(PixelMap pm, Graphics.Rectangle rect, int subsample, double gamma)
{
if (Info == null)
{
return false;
}
int width = Info.Width;
int height = Info.Height;
if ((width <= 0) || (height <= 0))
{
return false;
}
double gamma_correction = 1.0D;
if (gamma > 0.0D)
{
gamma_correction = gamma / Info.Gamma;
}
if (gamma_correction < 0.10000000000000001D)
{
gamma_correction = 0.10000000000000001D;
}
else if (gamma_correction > 10D)
{
gamma_correction = 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 GPixmap().Init(
1,
fgPalette.PaletteColors.Length,
null);
GPixelReference color = colors.CreateGPixelReference(0);
for (int i = 0; i < colors.ImageWidth; color.IncOffset())
{
fgPalette.index_to_color(i++, color);
}
colors.ApplyGammaCorrection(gamma_correction);
List<int> compset = new List<int>();
while (components.Count > 0)
{
int lastx = 0;
int colorindex = fgPalette.BlitColors[((int)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.ImageWidth,
pshape.Bitmap.ImageHeight);
comprect.Recthull(comprect, xrect);
compset.Add(components[pos]);
components.Remove(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 = getBitmap(comprect, subsample, 1);
bm = new GBitmap();
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.
IWPixelMap fgIWPixmap = ForegroundIWPixelMap;
if (fgIWPixmap != null)
{
GBitmap bm = GetBitmap(rect, subsample, 1, null);
if ((bm != null) && (pm != null))
{
GPixmap fgPixmap = ForegroundPixelMap;
int w = fgPixmap.ImageWidth;
int h = fgPixmap.ImageHeight;
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, gamma_correction);
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)
{
GPixmap pm = null;
int width = (Info == null)
? 0
: Info.Width;
int height = (Info == null)
? 0
: Info.Height;
if ((width <= 0) || (height <= 0) || (Info == null))
{
return null;
}
double gamma_correction = 1.0D;
if ((gamma > 0.0D) && (Info != null))
{
gamma_correction = gamma / Info.Gamma;
}
if (gamma_correction < 0.10000000000000001D)
{
gamma_correction = 0.10000000000000001D;
}
else if (gamma_correction > 10D)
{
gamma_correction = 10D;
}
IWPixelMap bgIWPixmap = BackgroundIWPixelMap;
if (bgIWPixmap != null)
{
int w = bgIWPixmap.Width;
int h = bgIWPixmap.Height;
if ((w == 0) || (h == 0) || (width == 0) || (height == 0))
{
return null;
}
int red = ComputeRed(width, height, w, h);
if ((red < 1) || (red > 12))
{
return null;
}
if (subsample == red)
{
pm = bgIWPixmap.GetPixmap(1, rect, retval);
}
else if (subsample == (2 * red))
{
pm = bgIWPixmap.GetPixmap(2, rect, retval);
}
else if (subsample == (4 * red))
{
pm = bgIWPixmap.GetPixmap(4, rect, retval);
}
else if (subsample == (8 * red))
{
pm = bgIWPixmap.GetPixmap(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 > w)
{
xrect.Left = w;
}
if (xrect.Top > h)
{
xrect.Top = h;
}
GPixmap ipm = bgIWPixmap.GetPixmap(1, xrect, null);
pm = (retval != null)
? retval
: new GPixmap();
pm.Downsample43(ipm, nrect);
}
else
{
int po2 = 16;
while ((po2 > 1) && (subsample < (po2 * red)))
{
po2 >>= 1;
}
int inw = ((w + po2) - 1) / po2;
int inh = ((h + po2) - 1) / po2;
int outw = ((width + subsample) - 1) / subsample;
int outh = ((height + subsample) - 1) / subsample;
PixelMapScaler ps = new PixelMapScaler(inw, inh, outw, outh);
ps.SetHorzRatio(red * po2, subsample);
ps.SetVertRatio(red * po2, subsample);
GRect xrect = ps.GetRequiredRect(rect);
GPixmap ipm = bgIWPixmap.GetPixmap(po2, xrect, null);
pm = (retval != null)
? retval
: new GPixmap();
ps.Scale(xrect, ipm, rect, pm);
}
if ((pm != null) && (gamma_correction != 1.0D))
{
pm.ApplyGammaCorrection(gamma_correction);
for (int i = 0; i < 9; i++)
{
pm.ApplyGammaCorrection(gamma_correction);
}
}
return pm;
}
else
{
return null;
}
}
public GBitmap GetBitmap(GRect rect, int subsample, int align, GBitmap retval)
{
return GetBitmapList(rect, 1, 1, null);
}
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>
/// Decodes the data for the zone
/// </summary>
/// <param name="reader"></param>
private void DecodeZoneData(DjvuReader reader, TextZone sibling, TextChunk chunkParent)
{
_zoneType = (ZoneTypes)reader.ReadByte();
_x = reader.ReadUInt16MSB() - 0x8000;
_y = reader.ReadUInt16MSB() - 0x8000;
_width = reader.ReadUInt16MSB() - 0x8000;
_height = reader.ReadUInt16MSB() - 0x8000;
_textOffset = reader.ReadUInt16MSB() - 0x8000;
_textLength = reader.ReadInt24MSB();
ResolveOffsets(_parent, sibling);
_rectangle = new Rectangle(_x, _y, _width, _height);
int childrenZones = reader.ReadInt24MSB();
List<TextZone> children = new List<TextZone>();
TextZone childrenSibling = null;
for (int x = 0; x < childrenZones; x++)
{
TextZone newZone = new TextZone(reader, this, childrenSibling, chunkParent);
childrenSibling = newZone;
children.Add(newZone);
}
_children = children.ToArray();
}