// conncomp.c (738, 1)
// pixSeedfill8BB(pixs, stack, x, y) as Box
// pixSeedfill8BB(PIX *, L_STACK *, l_int32, l_int32) as BOX *
/// <summary>
/// (1) This is Paul Heckbert's stack-based 8-cc seedfill algorithm.<para/>
///
/// (2) This operates on the input 1 bpp pix to remove the fg seed
/// pixel, at (x,y), and all pixels that are 8-connected to it.
/// The seed pixel at (x,y) must initially be ON.<para/>
///
/// (3) Returns the bounding box of the erased 8-cc component.<para/>
///
/// (4) Reference: see Paul Heckbert's stack-based seed fill algorithm
/// in "Graphic Gems", ed. Andrew Glassner, Academic
/// Press, 1990. The algorithm description is given
/// on pp. 275-277 working C code is on pp. 721-722.)
/// The code here follows Heckbert's closely, except
/// the leak checks are changed for 8 connectivity.
/// See comments on pixSeedfill4BB() for more details.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixSeedfill8BB/*"/>
/// <param name="pixs">[in] - 1 bpp</param>
/// <param name="stack">[in] - for holding fillsegs</param>
/// <param name="x">[in] - ,y location of seed pixel</param>
/// <returns>box or NULL on error.</returns>
public static Box pixSeedfill8BB(
Pix pixs,
L_Stack stack,
int x,
int y)
{
if (pixs == null)
{
throw new ArgumentNullException("pixs cannot be Nothing");
}
if (stack == null)
{
throw new ArgumentNullException("stack cannot be Nothing");
}
if ((new List <int> {
1
}).Contains((int)pixs.d) == false)
{
throw new ArgumentException("1 bpp");
}
IntPtr _Result = Natives.pixSeedfill8BB(pixs.Pointer, stack.Pointer, x, y);
if (_Result == IntPtr.Zero)
{
return(null);
}
return(new Box(_Result));
}
// conncomp.c (982, 1)
// pixSeedfill8(pixs, stack, x, y) as int
// pixSeedfill8(PIX *, L_STACK *, l_int32, l_int32) as l_ok
/// <summary>
/// (1) This is Paul Heckbert's stack-based 8-cc seedfill algorithm.<para/>
///
/// (2) This operates on the input 1 bpp pix to remove the fg seed
/// pixel, at (x,y), and all pixels that are 8-connected to it.
/// The seed pixel at (x,y) must initially be ON.<para/>
///
/// (3) Reference: see pixSeedFill8BB()
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixSeedfill8/*"/>
/// <param name="pixs">[in] - 1 bpp</param>
/// <param name="stack">[in] - for holding fillsegs</param>
/// <param name="x">[in] - ,y location of seed pixel</param>
/// <returns>0 if OK, 1 on error</returns>
public static int pixSeedfill8(
Pix pixs,
L_Stack stack,
int x,
int y)
{
if (pixs == null)
{
throw new ArgumentNullException("pixs cannot be Nothing");
}
if (stack == null)
{
throw new ArgumentNullException("stack cannot be Nothing");
}
if ((new List <int> {
1
}).Contains((int)pixs.d) == false)
{
throw new ArgumentException("1 bpp");
}
int _Result = Natives.pixSeedfill8(pixs.Pointer, stack.Pointer, x, y);
return(_Result);
}
// stack.c (247, 1)
// lstackGetCount(lstack) as int
// lstackGetCount(L_STACK *) as l_int32
/// <summary>
/// lstackGetCount()
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/lstackGetCount/*"/>
/// <param name="lstack">[in] - </param>
/// <returns>count, or 0 on error</returns>
public static int lstackGetCount(
L_Stack lstack)
{
if (lstack == null)
{
throw new ArgumentNullException("lstack cannot be Nothing");
}
int _Result = Natives.lstackGetCount(lstack.Pointer);
return(_Result);
}
// stack.c (197, 1)
// lstackRemove(lstack) as Object
// lstackRemove(L_STACK *) as void *
/// <summary>
/// lstackRemove()
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/lstackRemove/*"/>
/// <param name="lstack">[in] - </param>
/// <returns>ptr to item popped from the top of the lstack, or NULL if the lstack is empty or on error</returns>
public static Object lstackRemove(
L_Stack lstack)
{
if (lstack == null)
{
throw new ArgumentNullException("lstack cannot be Nothing");
}
IntPtr _Result = Natives.lstackRemove(lstack.Pointer);
Byte[] B = new Byte[1];
Marshal.Copy(_Result, B, 0, B.Length);
return(B);
}
// stack.c (270, 1)
// lstackPrint(fp, lstack) as int
// lstackPrint(FILE *, L_STACK *) as l_ok
/// <summary>
/// lstackPrint()
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/lstackPrint/*"/>
/// <param name="fp">[in] - file stream</param>
/// <param name="lstack">[in] - </param>
/// <returns>0 if OK 1 on error</returns>
public static int lstackPrint(
FILE fp,
L_Stack lstack)
{
if (fp == null)
{
throw new ArgumentNullException("fp cannot be Nothing");
}
if (lstack == null)
{
throw new ArgumentNullException("lstack cannot be Nothing");
}
int _Result = Natives.lstackPrint(fp.Pointer, lstack.Pointer);
return(_Result);
}
// stack.c (121, 1)
// lstackDestroy(plstack, freeflag) as Object
// lstackDestroy(L_STACK **, l_int32) as void
/// <summary>
/// (1) If freeflag is TRUE, frees each struct in the array.<para/>
///
/// (2) If freeflag is FALSE but there are elements on the array,
/// gives a warning and destroys the array. This will
/// cause a memory leak of all the items that were on the lstack.
/// So if the items require their own destroy function, they
/// must be destroyed before the lstack.<para/>
///
/// (3) To destroy the lstack, we destroy the ptr array, then
/// the lstack, and then null the contents of the input ptr.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/lstackDestroy/*"/>
/// <param name="plstack">[in,out] - to be nulled</param>
/// <param name="freeflag">[in] - TRUE to free each remaining struct in the array</param>
public static void lstackDestroy(
ref L_Stack plstack,
int freeflag)
{
IntPtr plstackPtr = IntPtr.Zero; if (plstack != null)
{
plstackPtr = plstack.Pointer;
}
Natives.lstackDestroy(ref plstackPtr, freeflag);
if (plstackPtr == IntPtr.Zero)
{
plstack = null;
}
else
{
plstack = new L_Stack(plstackPtr);
};
}
// stack.c (167, 1)
// lstackAdd(lstack, item) as int
// lstackAdd(L_STACK *, void *) as l_ok
/// <summary>
/// lstackAdd()
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/lstackAdd/*"/>
/// <param name="lstack">[in] - </param>
/// <param name="item">[in] - to be added to the lstack</param>
/// <returns>0 if OK 1 on error.</returns>
public static int lstackAdd(
L_Stack lstack,
Object item)
{
if (lstack == null)
{
throw new ArgumentNullException("lstack cannot be Nothing");
}
if (item == null)
{
throw new ArgumentNullException("item cannot be Nothing");
}
IntPtr itemPtr = IntPtr.Zero;
if (item.GetType() == typeof(IntPtr))
{
itemPtr = (IntPtr)item;
}
else if (item.GetType() == typeof(Byte[]))
{
var cdata = (Byte[])item;
itemPtr = Marshal.AllocHGlobal(cdata.Length);
Marshal.Copy(cdata, 0, itemPtr, cdata.Length);
}
else if (item.GetType().GetProperty("item") != null)
{
var cdata = (Byte[])item.GetType().GetProperty("data").GetValue(item, null);
itemPtr = Marshal.AllocHGlobal(cdata.Length);
Marshal.Copy(cdata, 0, itemPtr, cdata.Length);
}
int _Result = Natives.lstackAdd(lstack.Pointer, itemPtr);
Marshal.FreeHGlobal(itemPtr);
return(_Result);
}
