// writefile.c (666, 1)
// getFormatExtension(format) as String
// getFormatExtension(l_int32) as const char *
/// <summary>
/// (1) This string is NOT owned by the caller it is just a pointer
/// to a global string. Do not free it.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/getFormatExtension/*"/>
/// <param name="format">[in] - integer</param>
/// <returns>extension string, or NULL if format is out of range</returns>
public static String getFormatExtension(
Enumerations.IFF format)
{
String _Result = Natives.getFormatExtension((int)format);
return(_Result);
}
// readbarcode.c (134, 1)
// pixProcessBarcodes(pixs, format, method, psaw, debugflag) as Sarray
// pixProcessBarcodes(PIX *, l_int32, l_int32, SARRAY **, l_int32) as SARRAY *
/// <summary>
/// pixProcessBarcodes()
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixProcessBarcodes/*"/>
/// <param name="pixs">[in] - any depth</param>
/// <param name="format">[in] - L_BF_ANY, L_BF_CODEI2OF5, L_BF_CODE93, ...</param>
/// <param name="method">[in] - L_USE_WIDTHS, L_USE_WINDOWS</param>
/// <param name="psaw">[out][optional] - sarray of bar widths</param>
/// <param name="debugflag">[in] - use 1 to generate debug output</param>
/// <returns>sarray text of barcodes, or NULL if none found or on error</returns>
public static Sarray pixProcessBarcodes(
Pix pixs,
Enumerations.IFF format,
int method,
out Sarray psaw,
int debugflag)
{
if (pixs == null)
{
throw new ArgumentNullException("pixs cannot be Nothing");
}
IntPtr psawPtr = IntPtr.Zero;
IntPtr _Result = Natives.pixProcessBarcodes(pixs.Pointer, (int)format, method, out psawPtr, debugflag);
if (psawPtr == IntPtr.Zero)
{
psaw = null;
}
else
{
psaw = new Sarray(psawPtr);
};
if (_Result == IntPtr.Zero)
{
return(null);
}
return(new Sarray(_Result));
}
// bardecode.c (173, 1)
// barcodeFormatIsSupported(format) as int
// barcodeFormatIsSupported(l_int32) as l_int32
/// <summary>
/// barcodeFormatIsSupported()
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/barcodeFormatIsSupported/*"/>
/// <param name="format">[in] - </param>
/// <returns>1 if format is one of those supported 0 otherwise</returns>
public static int barcodeFormatIsSupported(
Enumerations.IFF format)
{
int _Result = Natives.barcodeFormatIsSupported((int)format);
return(_Result);
}
// regutils.c (821, 1)
// regTestGenLocalFilename(rp, index, format) as String
// regTestGenLocalFilename(L_REGPARAMS *, l_int32, l_int32) as char *
/// <summary>
/// (1) This is used to get the name of a file in the regout
/// subdirectory, that has been made and is used to test against
/// the golden file. You can either specify a particular index
/// value, or with %index == -1, this returns the most recently
/// written file. The latter case lets you read a pix from a
/// file that has just been written with regTestWritePixAndCheck(),
/// which is useful for testing formatted read/write functions.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/regTestGenLocalFilename/*"/>
/// <param name="rp">[in] - regtest parameters</param>
/// <param name="index">[in] - use -1 for current index</param>
/// <param name="format">[in] - of image e.g., IFF_PNG</param>
/// <returns>filename if OK, or NULL on error</returns>
public static String regTestGenLocalFilename(
L_RegParams rp,
int index,
Enumerations.IFF format)
{
if (rp == null)
{
throw new ArgumentNullException("rp cannot be Nothing");
}
String _Result = Natives.regTestGenLocalFilename(rp.Pointer, index, (int)format);
return(_Result);
}
// bardecode.c (96, 1)
// barcodeDispatchDecoder(barstr, format, debugflag) as String
// barcodeDispatchDecoder(char *, l_int32, l_int32) as char *
/// <summary>
/// barcodeDispatchDecoder()
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/barcodeDispatchDecoder/*"/>
/// <param name="barstr">[in] - string of integers in set {1,2,3,4} of bar widths</param>
/// <param name="format">[in] - L_BF_ANY, L_BF_CODEI2OF5, L_BF_CODE93, ...</param>
/// <param name="debugflag">[in] - use 1 to generate debug output</param>
/// <returns>data string of decoded barcode data, or NULL on error</returns>
public static String barcodeDispatchDecoder(
String barstr,
Enumerations.IFF format,
int debugflag)
{
if (barstr == null)
{
throw new ArgumentNullException("barstr cannot be Nothing");
}
String _Result = Natives.barcodeDispatchDecoder(barstr, (int)format, debugflag);
return(_Result);
}
// writefile.c (242, 1)
// pixaWriteFiles(rootname, pixa, format) as int
// pixaWriteFiles(const char *, PIXA *, l_int32) as l_ok
/// <summary>
/// (1) Use %format = IFF_DEFAULT to decide the output format
/// individually for each pix.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixaWriteFiles/*"/>
/// <param name="rootname">[in] - </param>
/// <param name="pixa">[in] - </param>
/// <param name="format">[in] - defined in imageio.h see notes for default</param>
/// <returns>0 if OK 1 on error</returns>
public static int pixaWriteFiles(
String rootname,
Pixa pixa,
Enumerations.IFF format)
{
if (rootname == null)
{
throw new ArgumentNullException("rootname cannot be Nothing");
}
if (pixa == null)
{
throw new ArgumentNullException("pixa cannot be Nothing");
}
int _Result = Natives.pixaWriteFiles(rootname, pixa.Pointer, (int)format);
return(_Result);
}
// writefile.c (392, 1)
// pixWriteStream(fp, pix, format) as int
// pixWriteStream(FILE *, PIX *, l_int32) as l_ok
/// <summary>
/// pixWriteStream()
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixWriteStream/*"/>
/// <param name="fp">[in] - file stream</param>
/// <param name="pix">[in] - </param>
/// <param name="format">[in] - </param>
/// <returns>0 if OK 1 on error.</returns>
public static int pixWriteStream(
FILE fp,
Pix pix,
Enumerations.IFF format)
{
if (fp == null)
{
throw new ArgumentNullException("fp cannot be Nothing");
}
if (pix == null)
{
throw new ArgumentNullException("pix cannot be Nothing");
}
int _Result = Natives.pixWriteStream(fp.Pointer, pix.Pointer, (int)format);
return(_Result);
}
// writefile.c (332, 1)
// pixWrite(fname, pix, format) as int
// pixWrite(const char *, PIX *, l_int32) as l_ok
/// <summary>
/// (1) Open for write using binary mode (with the "b" flag)
/// to avoid having Windows automatically translate the NL
/// into CRLF, which corrupts image files. On non-windows
/// systems this flag should be ignored, per ISO C90.
/// Thanks to Dave Bryan for pointing this out.<para/>
///
/// (2) If the default image format IFF_DEFAULT is requested:
/// use the input format if known otherwise, use a lossless format.<para/>
///
/// (3) The default jpeg quality is 75. For some other value,
/// Use l_jpegSetQuality().
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixWrite/*"/>
/// <param name="fname">[in] - </param>
/// <param name="pix">[in] - </param>
/// <param name="format">[in] - defined in imageio.h</param>
/// <returns>0 if OK 1 on error</returns>
public static int pixWrite(
String fname,
Pix pix,
Enumerations.IFF format)
{
if (fname == null)
{
throw new ArgumentNullException("fname cannot be Nothing");
}
if (pix == null)
{
throw new ArgumentNullException("pix cannot be Nothing");
}
int _Result = Natives.pixWrite(fname, pix.Pointer, (int)format);
return(_Result);
}
// regutils.c (704, 1)
// regTestWritePixAndCheck(rp, pix, format) as int
// regTestWritePixAndCheck(L_REGPARAMS *, PIX *, l_int32) as l_ok
/// <summary>
/// (1) This function makes it easy to write the pix in a numbered
/// sequence of files, and either to:
/// (a) write the golden file ("generate" arg to regression test)
/// (b) make a local file and "compare" with the golden file
/// (c) make a local file and "display" the results<para/>
///
/// (2) The canonical format of the local filename is:
/// /tmp/lept/regout/[root of main name].[count].[format extension]
/// e.g., for scale_reg,
/// /tmp/lept/regout/scale.0.png
/// The golden file name mirrors this in the usual way.<para/>
///
/// (3) The check is done between the written files, which requires
/// the files to be identical. The exception is for GIF, which
/// only requires that all pixels in the decoded pix are identical.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/regTestWritePixAndCheck/*"/>
/// <param name="rp">[in] - regtest parameters</param>
/// <param name="pix">[in] - to be written</param>
/// <param name="format">[in] - of output pix</param>
/// <returns>0 if OK, 1 on error a failure in comparison is not an error</returns>
public static int regTestWritePixAndCheck(
L_RegParams rp,
Pix pix,
Enumerations.IFF format)
{
if (rp == null)
{
throw new ArgumentNullException("rp cannot be Nothing");
}
if (pix == null)
{
throw new ArgumentNullException("pix cannot be Nothing");
}
int _Result = Natives.regTestWritePixAndCheck(rp.Pointer, pix.Pointer, (int)format);
return(_Result);
}
// writefile.c (701, 1)
// pixWriteMem(pdata, psize, pix, format) as int
// pixWriteMem(l_uint8 **, size_t *, PIX *, l_int32) as l_ok
/// <summary>
/// (1) On windows, this will only write tiff and PostScript to memory.
/// For other formats, it requires open_memstream(3).<para/>
///
/// (2) PostScript output is uncompressed, in hex ascii.
/// Most printers support level 2 compression (tiff_g4 for 1 bpp,
/// jpeg for 8 and 32 bpp).<para/>
///
/// (3) The default jpeg quality is 75. For some other value,
/// Use l_jpegSetQuality().
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixWriteMem/*"/>
/// <param name="pdata">[out] - data of tiff compressed image</param>
/// <param name="psize">[out] - size of returned data</param>
/// <param name="pix">[in] - </param>
/// <param name="format">[in] - defined in imageio.h</param>
/// <returns>0 if OK, 1 on error</returns>
public static int pixWriteMem(
out Byte[] pdata,
out uint psize,
Pix pix,
Enumerations.IFF format)
{
if (pix == null)
{
throw new ArgumentNullException("pix cannot be Nothing");
}
IntPtr pdataPtr = IntPtr.Zero;
int _Result = Natives.pixWriteMem(out pdataPtr, out psize, pix.Pointer, (int)format);
Byte[] pdataGen = new Byte[psize];
if (pdataPtr != IntPtr.Zero)
{
Marshal.Copy(pdataPtr, pdataGen, 0, pdataGen.Length);
}
pdata = pdataGen;
return(_Result);
}