// projective.c (513, 1)
// pixProjectivePtaGray(pixs, ptad, ptas, grayval) as Pix
// pixProjectivePtaGray(PIX *, PTA *, PTA *, l_uint8) as PIX *
/// <summary>
/// pixProjectivePtaGray()
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixProjectivePtaGray/*"/>
/// <param name="pixs">[in] - 8 bpp</param>
/// <param name="ptad">[in] - 4 pts of final coordinate space</param>
/// <param name="ptas">[in] - 4 pts of initial coordinate space</param>
/// <param name="grayval">[in] - 0 to bring in BLACK, 255 for WHITE</param>
/// <returns>pixd, or NULL on error</returns>
public static Pix pixProjectivePtaGray(
Pix pixs,
Pta ptad,
Pta ptas,
byte grayval)
{
if (pixs == null)
{
throw new ArgumentNullException("pixs cannot be Nothing");
}
if (ptad == null)
{
throw new ArgumentNullException("ptad cannot be Nothing");
}
if (ptas == null)
{
throw new ArgumentNullException("ptas cannot be Nothing");
}
if ((new List <int> {
8
}).Contains((int)pixs.d) == false)
{
throw new ArgumentException("8 bpp");
}
IntPtr _Result = Natives.pixProjectivePtaGray(pixs.Pointer, ptad.Pointer, ptas.Pointer, grayval);
if (_Result == IntPtr.Zero)
{
return(null);
}
return(new Pix(_Result));
}
// ptabasic.c (888, 1)
// ptaWriteMem(pdata, psize, pta, type) as int
// ptaWriteMem(l_uint8 **, size_t *, PTA *, l_int32) as l_ok
/// <summary>
/// (1) Serializes a pta in memory and puts the result in a buffer.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/ptaWriteMem/*"/>
/// <param name="pdata">[out] - data of serialized pta ascii</param>
/// <param name="psize">[out] - size of returned data</param>
/// <param name="pta">[in] - </param>
/// <param name="type">[in] - 0 for float values 1 for integer values</param>
/// <returns>0 if OK, 1 on error</returns>
public static int ptaWriteMem(
out Byte[] pdata,
out uint psize,
Pta pta,
int type)
{
if (pta == null)
{
throw new ArgumentNullException("pta cannot be Nothing");
}
IntPtr pdataPtr = IntPtr.Zero;
int _Result = Natives.ptaWriteMem(out pdataPtr, out psize, pta.Pointer, type);
Byte[] pdataGen = new Byte[psize];
if (pdataPtr != IntPtr.Zero)
{
Marshal.Copy(pdataPtr, pdataGen, 0, pdataGen.Length);
}
pdata = pdataGen;
return(_Result);
}
// boxfunc2.c (1170, 1)
// boxaExtractAsPta(boxa, pptal, pptat, pptar, pptab, pptaw, pptah, keepinvalid) as int
// boxaExtractAsPta(BOXA *, PTA **, PTA **, PTA **, PTA **, PTA **, PTA **, l_int32) as l_ok
/// <summary>
/// (1) For most applications, such as counting, sorting, fitting
/// to some parametrized form, plotting or filtering in general,
/// you should remove the invalid boxes. Each pta saves the
/// box index in the x array, so replacing invalid boxes by
/// filling with boxaFillSequence(), which is required for
/// boxaExtractAsNuma(), is not necessary.<para/>
///
/// (2) If invalid boxes are retained, each one will result in
/// entries (typically 0) in all selected output pta.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/boxaExtractAsPta/*"/>
/// <param name="boxa">[in] - </param>
/// <param name="pptal">[out][optional] - array of left locations vs. index</param>
/// <param name="pptat">[out][optional] - array of top locations vs. index</param>
/// <param name="pptar">[out][optional] - array of right locations vs. index</param>
/// <param name="pptab">[out][optional] - array of bottom locations vs. index</param>
/// <param name="pptaw">[out][optional] - array of widths vs. index</param>
/// <param name="pptah">[out][optional] - array of heights vs. index</param>
/// <param name="keepinvalid">[in] - 1 to keep invalid boxes 0 to remove them</param>
/// <returns>0 if OK, 1 on error</returns>
public static int boxaExtractAsPta(
Boxa boxa,
out Pta pptal,
out Pta pptat,
out Pta pptar,
out Pta pptab,
out Pta pptaw,
out Pta pptah,
int keepinvalid)
{
if (boxa == null)
{
throw new ArgumentNullException("boxa cannot be Nothing");
}
IntPtr pptalPtr = IntPtr.Zero;
IntPtr pptatPtr = IntPtr.Zero;
IntPtr pptarPtr = IntPtr.Zero;
IntPtr pptabPtr = IntPtr.Zero;
IntPtr pptawPtr = IntPtr.Zero;
IntPtr pptahPtr = IntPtr.Zero;
int _Result = Natives.boxaExtractAsPta(boxa.Pointer, out pptalPtr, out pptatPtr, out pptarPtr, out pptabPtr, out pptawPtr, out pptahPtr, keepinvalid);
if (pptalPtr == IntPtr.Zero)
{
pptal = null;
}
else
{
pptal = new Pta(pptalPtr);
};
if (pptatPtr == IntPtr.Zero)
{
pptat = null;
}
else
{
pptat = new Pta(pptatPtr);
};
if (pptarPtr == IntPtr.Zero)
{
pptar = null;
}
else
{
pptar = new Pta(pptarPtr);
};
if (pptabPtr == IntPtr.Zero)
{
pptab = null;
}
else
{
pptab = new Pta(pptabPtr);
};
if (pptawPtr == IntPtr.Zero)
{
pptaw = null;
}
else
{
pptaw = new Pta(pptawPtr);
};
if (pptahPtr == IntPtr.Zero)
{
pptah = null;
}
else
{
pptah = new Pta(pptahPtr);
};
return(_Result);
}
