// jp2kiostub.c (71, 6)
// pixWriteStreamJp2k(fp, pix, quality, nlevels, hint, debug) as int
// pixWriteStreamJp2k(FILE *, PIX *, l_int32, l_int32, l_int32, l_int32) as l_ok
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixWriteStreamJp2k/*"/>
/// <returns></returns>
public static int pixWriteStreamJp2k(
FILE fp,
Pix pix,
int quality,
int nlevels,
int hint,
Enumerations.DebugOnOff debug)
{
if (fp == null)
{
throw new ArgumentNullException("fp cannot be Nothing");
}
if (pix == null)
{
throw new ArgumentNullException("pix cannot be Nothing");
}
IntPtr fpPtr = IntPtr.Zero; if (fp != null)
{
fpPtr = fp.Pointer;
}
IntPtr pixPtr = IntPtr.Zero; if (pix != null)
{
pixPtr = pix.Pointer;
}
int _Result = Natives.pixWriteStreamJp2k(fp.Pointer, pix.Pointer, quality, nlevels, hint, (int)debug);
return(_Result);
}
// recogtrain.c (1488, 1)
// recogTrainFromBoot(recogboot, pixas, minscore, threshold, debug) as Pixa
// recogTrainFromBoot(L_RECOG *, PIXA *, l_float32, l_int32, l_int32) as PIXA *
/// <summary>
/// (1) This takes %pixas of unscaled single characters and %recboot,
/// a bootstrep recognizer (BSR) that has been set up with parameters
/// scaleh: scale all templates to this height
/// linew: width of normalized strokes, or 0 if using
/// the input image
/// It modifies the pix in %pixas accordingly and correlates
/// with the templates in the BSR. It returns those input
/// images in %pixas whose best correlation with the BSR is at
/// or above %minscore. The returned pix have added text labels
/// for the text string of the class to which the best
/// correlated template belongs.<para/>
///
/// (2) Identification occurs in scaled mode (typically with h = 40),
/// optionally using a width-normalized line images derived
/// from those in %pixas.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/recogTrainFromBoot/*"/>
/// <param name="recogboot">[in] - labeled boot recognizer</param>
/// <param name="pixas">[in] - set of unlabeled input characters</param>
/// <param name="minscore">[in] - min score for accepting the example e.g., 0.75</param>
/// <param name="threshold">[in] - for binarization, if needed</param>
/// <param name="debug">[in] - 1 for debug output saved to recogboot 0 otherwise</param>
/// <returns>pixad labeled version of input pixas, trained on a BSR, or NULL on error</returns>
public static Pixa recogTrainFromBoot(
L_Recog recogboot,
Pixa pixas,
Single minscore,
int threshold,
Enumerations.DebugOnOff debug = DebugOnOff.DebugOn)
{
if (recogboot == null)
{
throw new ArgumentNullException("recogboot cannot be Nothing");
}
if (pixas == null)
{
throw new ArgumentNullException("pixas cannot be Nothing");
}
IntPtr _Result = Natives.recogTrainFromBoot(recogboot.Pointer, pixas.Pointer, minscore, threshold, (int)debug);
if (_Result == IntPtr.Zero)
{
return(null);
}
return(new Pixa(_Result));
}
// jp2kiostub.c (63, 6)
// pixWriteJp2k(filename, pix, quality, nlevels, hint, debug) as int
// pixWriteJp2k(const char *, PIX *, l_int32, l_int32, l_int32, l_int32) as l_ok
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixWriteJp2k/*"/>
/// <returns></returns>
public static int pixWriteJp2k(
String filename,
Pix pix,
int quality,
int nlevels,
int hint,
Enumerations.DebugOnOff debug)
{
if (filename == null)
{
throw new ArgumentNullException("filename cannot be Nothing");
}
if (pix == null)
{
throw new ArgumentNullException("pix cannot be Nothing");
}
IntPtr pixPtr = IntPtr.Zero; if (pix != null)
{
pixPtr = pix.Pointer;
}
int _Result = Natives.pixWriteJp2k(filename, pix.Pointer, quality, nlevels, hint, (int)debug);
return(_Result);
}
// recogident.c (401, 1)
// recogCorrelationBestRow(recog, pixs, pboxa, pnascore, pnaindex, psachar, debug) as int
// recogCorrelationBestRow(L_RECOG *, PIX *, BOXA **, NUMA **, NUMA **, SARRAY **, l_int32) as l_ok
/// <summary>
/// (1) Supervises character matching for (in general) a c.c with
/// multiple touching characters. Finds the best match greedily.
/// Rejects small parts that are left over after splitting.<para/>
///
/// (2) Matching is to the average, and without character scaling.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/recogCorrelationBestRow/*"/>
/// <param name="recog">[in] - with LUT's pre-computed</param>
/// <param name="pixs">[in] - typically of multiple touching characters, 1 bpp</param>
/// <param name="pboxa">[out] - bounding boxs of best fit character</param>
/// <param name="pnascore">[out][optional] - correlation scores</param>
/// <param name="pnaindex">[out][optional] - indices of classes</param>
/// <param name="psachar">[out][optional] - array of character strings</param>
/// <param name="debug">[in] - 1 for results written to pixadb_split</param>
/// <returns>0 if OK, 1 on error</returns>
public static int recogCorrelationBestRow(
L_Recog recog,
Pix pixs,
out Boxa pboxa,
out Numa pnascore,
out Numa pnaindex,
out Sarray psachar,
Enumerations.DebugOnOff debug = DebugOnOff.DebugOn)
{
if (recog == null)
{
throw new ArgumentNullException("recog cannot be Nothing");
}
if (pixs == null)
{
throw new ArgumentNullException("pixs cannot be Nothing");
}
IntPtr pboxaPtr = IntPtr.Zero;
IntPtr pnascorePtr = IntPtr.Zero;
IntPtr pnaindexPtr = IntPtr.Zero;
IntPtr psacharPtr = IntPtr.Zero;
int _Result = Natives.recogCorrelationBestRow(recog.Pointer, pixs.Pointer, out pboxaPtr, out pnascorePtr, out pnaindexPtr, out psacharPtr, (int)debug);
if (pboxaPtr == IntPtr.Zero)
{
pboxa = null;
}
else
{
pboxa = new Boxa(pboxaPtr);
};
if (pnascorePtr == IntPtr.Zero)
{
pnascore = null;
}
else
{
pnascore = new Numa(pnascorePtr);
};
if (pnaindexPtr == IntPtr.Zero)
{
pnaindex = null;
}
else
{
pnaindex = new Numa(pnaindexPtr);
};
if (psacharPtr == IntPtr.Zero)
{
psachar = null;
}
else
{
psachar = new Sarray(psacharPtr);
};
return(_Result);
}
// recogtrain.c (212, 1)
// recogTrainLabeled(recog, pixs, box, text, debug) as int
// recogTrainLabeled(L_RECOG *, PIX *, BOX *, char *, l_int32) as l_ok
/// <summary>
/// (1) Training is restricted to the addition of a single
/// character in an arbitrary (e.g., UTF8) charset<para/>
///
/// (2) If box != null, it should represent the location in %pixs
/// of the character image.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/recogTrainLabeled/*"/>
/// <param name="recog">[in] - in training mode</param>
/// <param name="pixs">[in] - if depth is greater 1, will be thresholded to 1 bpp</param>
/// <param name="box">[in][optional] - cropping box</param>
/// <param name="text">[in][optional] - if null, use text field in pix</param>
/// <param name="debug">[in] - 1 to display images of samples not captured</param>
/// <returns>0 if OK, 1 on error</returns>
public static int recogTrainLabeled(
L_Recog recog,
Pix pixs,
Box box = null,
String text = "",
Enumerations.DebugOnOff debug = DebugOnOff.DebugOn)
{
if (recog == null)
{
throw new ArgumentNullException("recog cannot be Nothing");
}
if (pixs == null)
{
throw new ArgumentNullException("pixs cannot be Nothing");
}
IntPtr boxPtr = IntPtr.Zero; if (box != null)
{
boxPtr = box.Pointer;
}
int _Result = Natives.recogTrainLabeled(recog.Pointer, pixs.Pointer, boxPtr, text, (int)debug);
return(_Result);
}
// jp2kiostub.c (87, 6)
// pixWriteMemJp2k(pdata, psize, pix, quality, nlevels, hint, debug) as int
// pixWriteMemJp2k(l_uint8 **, size_t *, PIX *, l_int32, l_int32, l_int32, l_int32) as l_ok
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixWriteMemJp2k/*"/>
/// <returns></returns>
public static int pixWriteMemJp2k(
object pdata,
object psize,
Pix pix,
int quality,
int nlevels,
int hint,
Enumerations.DebugOnOff debug)
{
if (pdata == null)
{
throw new ArgumentNullException("pdata cannot be Nothing");
}
if (psize == null)
{
throw new ArgumentNullException("psize cannot be Nothing");
}
if (pix == null)
{
throw new ArgumentNullException("pix cannot be Nothing");
}
IntPtr pixPtr = IntPtr.Zero; if (pix != null)
{
pixPtr = pix.Pointer;
}
int _Result = Natives.pixWriteMemJp2k(pdata, psize, pix.Pointer, quality, nlevels, hint, (int)debug);
return(_Result);
}
// recogtrain.c (1911, 1)
// recogMakeBootDigitTemplates(debug) as Pixa
// recogMakeBootDigitTemplates(l_int32) as PIXA *
/// <summary>
/// (1) See recogMakeBootDigitRecog().
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/recogMakeBootDigitTemplates/*"/>
/// <param name="debug">[in] - 1 for display of templates</param>
/// <returns>pixa of templates or NULL on error</returns>
public static Pixa recogMakeBootDigitTemplates(
Enumerations.DebugOnOff debug)
{
IntPtr _Result = Natives.recogMakeBootDigitTemplates((int)debug);
if (_Result == IntPtr.Zero)
{
return(null);
}
return(new Pixa(_Result));
}
// flipdetect.c (431, 1)
// makeOrientDecision(upconf, leftconf, minupconf, minratio, porient, debug) as int
// makeOrientDecision(l_float32, l_float32, l_float32, l_float32, l_int32 *, l_int32) as l_ok
/// <summary>
/// (1) This can be run after pixOrientDetect()<para/>
///
/// (2) Both upconf and leftconf must be nonzero otherwise the
/// orientation cannot be determined.<para/>
///
/// (3) The abs values of the input confidences are compared to
/// minupconf.<para/>
///
/// (4) The abs value of the largest of (upconf/leftconf) and
/// (leftconf/upconf) is compared with minratio.<para/>
///
/// (5) Input 0.0 for the default values for minupconf and minratio.<para/>
///
/// (6) The return value of orient is interpreted thus:
/// L_TEXT_ORIENT_UNKNOWN: not enough evidence to determine
/// L_TEXT_ORIENT_UP: text rightside-up
/// L_TEXT_ORIENT_LEFT: landscape, text up facing left
/// L_TEXT_ORIENT_DOWN: text upside-down
/// L_TEXT_ORIENT_RIGHT: landscape, text up facing right
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/makeOrientDecision/*"/>
/// <param name="upconf">[in] - nonzero</param>
/// <param name="leftconf">[in] - nonzero</param>
/// <param name="minupconf">[in] - minimum value for which a decision can be made</param>
/// <param name="minratio">[in] - minimum conf ratio required for a decision</param>
/// <param name="porient">[out] - text orientation enum {0,1,2,3,4}</param>
/// <param name="debug">[in] - 1 for debug output 0 otherwise</param>
/// <returns>0 if OK, 1 on error</returns>
public static int makeOrientDecision(
Single upconf,
Single leftconf,
Single minupconf,
Single minratio,
out int porient,
Enumerations.DebugOnOff debug = DebugOnOff.DebugOn)
{
int _Result = Natives.makeOrientDecision(upconf, leftconf, minupconf, minratio, out porient, (int)debug);
return(_Result);
}
// ccthin.c (341, 1)
// selaMakeThinSets(index, debug) as Sela
// selaMakeThinSets(l_int32, l_int32) as SELA *
/// <summary>
/// (1) These are specific sets of HMTs to be used in parallel for
/// for thinning from each of four directions.<para/>
///
/// (2) The sets are indexed as follows:
/// For thinning (e.g., run to completion):
/// index = 1 sel_4_1, sel_4_2, sel_4_3
/// index = 2 sel_4_1, sel_4_5, sel_4_6
/// index = 3 sel_4_1, sel_4_7, sel_4_7_rot
/// index = 4 sel_48_1, sel_48_1_rot, sel_48_2
/// index = 5 sel_8_2, sel_8_3, sel_8_5, sel_8_6
/// index = 6 sel_8_2, sel_8_3, sel_48_2
/// index = 7 sel_8_1, sel_8_5, sel_8_6
/// index = 8 sel_8_2, sel_8_3, sel_8_8, sel_8_9
/// index = 9 sel_8_5, sel_8_6, sel_8_7, sel_8_7_rot
/// For thickening (e.g., just a few iterations):
/// index = 10 sel_4_2, sel_4_3
/// index = 11 sel_8_4<para/>
///
/// (3) For a very smooth skeleton, use set 1 for 4 connected and
/// set 5 for 8 connected thins.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/selaMakeThinSets/*"/>
/// <param name="index">[in] - into specific sets</param>
/// <param name="debug">[in] - 1 to output display of sela</param>
/// <returns>sela, or NULL on error</returns>
public static Sela selaMakeThinSets(
int index,
Enumerations.DebugOnOff debug = DebugOnOff.DebugOn)
{
IntPtr _Result = Natives.selaMakeThinSets(index, (int)debug);
if (_Result == IntPtr.Zero)
{
return(null);
}
return(new Sela(_Result));
}
// recogtrain.c (2045, 1)
// recogDebugAverages(precog, debug) as int
// recogDebugAverages(L_RECOG **, l_int32) as l_ok
/// <summary>
/// (1) Generates an image that pairs each of the input images used
/// in training with the average template that it is best
/// correlated to. This is written into the recog.<para/>
///
/// (2) It also generates pixa_tr of all the input training images,
/// which can be used, e.g., in recogShowMatchesInRange().<para/>
///
/// (3) Destroys the recog if the averaging function finds any bad classes.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/recogDebugAverages/*"/>
/// <param name="precog">[in] - addr of recog</param>
/// <param name="debug">[in] - 0 no output 1 for images 2 for text 3 for both</param>
/// <returns>0 if OK, 1 on error</returns>
public static int recogDebugAverages(
List <L_Recog> precog,
Enumerations.DebugOnOff debug = DebugOnOff.DebugOn)
{
if (precog == null)
{
throw new ArgumentNullException("precog cannot be Nothing");
}
IntPtr precogPtr = IntPtr.Zero;
int _Result = Natives.recogDebugAverages(precogPtr, (int)debug);
return(_Result);
}
// dewarp4.c (447, 1)
// dewarpaInsertRefModels(dewa, notests, debug) as int
// dewarpaInsertRefModels(L_DEWARPA *, l_int32, l_int32) as l_ok
/// <summary>
/// (1) This destroys all dewarp models that are invalid, and then
/// inserts reference models where possible.<para/>
///
/// (2) If %notests == 1, this ignores the curvature constraints
/// and assumes that all successfully built models are valid.<para/>
///
/// (3) If useboth == 0, it uses the closest valid model within the
/// distance and parity constraints. If useboth == 1, it tries
/// to use the closest allowed hvalid model if it doesn't find
/// an hvalid model, it uses the closest valid model.<para/>
///
/// (4) For all pages without a model, this clears out any existing
/// invalid and reference dewarps, finds the nearest valid model
/// with the same parity, and inserts an empty dewarp with the
/// reference page.<para/>
///
/// (5) Then if it is requested to use both vertical and horizontal
/// disparity arrays (useboth == 1), it tries to replace any
/// hvalid == 0 model or reference with an hvalid == 1 reference.<para/>
///
/// (6) The distance constraint is that any reference model must
/// be within maxdist. Note that with the parity constraint,
/// no reference models will be used if maxdist is smaller 2.<para/>
///
/// (7) This function must be called, even if reference models will
/// not be used. It should be called after building models on all
/// available pages, and after setting the rendering parameters.<para/>
///
/// (8) If the dewa has been serialized, this function is called by
/// dewarpaRead() when it is read back. It is also called
/// any time the rendering parameters are changed.<para/>
///
/// (9) Note: if this has been called with useboth == 1, and useboth
/// is reset to 0, you should first call dewarpaRestoreModels()
/// to bring real models from the cache back to the primary array.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/dewarpaInsertRefModels/*"/>
/// <param name="dewa">[in] - </param>
/// <param name="notests">[in] - if 1, ignore curvature constraints on model</param>
/// <param name="debug">[in] - 1 to output information on invalid page models</param>
/// <returns>0 if OK, 1 on error</returns>
public static int dewarpaInsertRefModels(
L_Dewarpa dewa,
int notests,
Enumerations.DebugOnOff debug = DebugOnOff.DebugOn)
{
if (dewa == null)
{
throw new ArgumentNullException("dewa cannot be Nothing");
}
int _Result = Natives.dewarpaInsertRefModels(dewa.Pointer, notests, (int)debug);
return(_Result);
}
// recogtrain.c (1876, 1)
// recogMakeBootDigitRecog(scaleh, linew, maxyshift, debug) as L_Recog
// recogMakeBootDigitRecog(l_int32, l_int32, l_int32, l_int32) as L_RECOG *
/// <summary>
/// (1) This takes a set of pre-computed, labeled pixa of single
/// digits, and generates a recognizer where the character templates
/// that will be used are derived from the boot-generated pixa:
/// - extending by replicating the set with different widths,
/// keeping the height the same
/// - scaling (isotropically to fixed height)
/// - optionally generating a skeleton and thickening so that
/// all strokes have the same width.<para/>
///
/// (2) The resulting templates are scaled versions of either the
/// input bitmaps or images with fixed line widths. To use the
/// input bitmaps, set %linew = 0 otherwise, set %linew to the
/// desired line width.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/recogMakeBootDigitRecog/*"/>
/// <param name="scaleh">[in] - scale all heights to this typ. use 40</param>
/// <param name="linew">[in] - normalized line width typ. use 5 0 to skip</param>
/// <param name="maxyshift">[in] - from nominal centroid alignment typically 0 or 1</param>
/// <param name="debug">[in] - 1 for showing templates 0 otherwise</param>
/// <returns>recog, or NULL on error</returns>
public static L_Recog recogMakeBootDigitRecog(
int scaleh,
int linew,
int maxyshift,
Enumerations.DebugOnOff debug = DebugOnOff.DebugOn)
{
IntPtr _Result = Natives.recogMakeBootDigitRecog(scaleh, linew, maxyshift, (int)debug);
if (_Result == IntPtr.Zero)
{
return(null);
}
return(new L_Recog(_Result));
}
// flipdetect.c (1025, 1)
// pixMirrorDetectDwa(pixs, pconf, mincount, debug) as int
// pixMirrorDetectDwa(PIX *, l_float32 *, l_int32, l_int32) as l_ok
/// <summary>
/// (1) We assume the text is horizontally oriented, with
/// ascenders going up.<para/>
///
/// (2) See notes in pixMirrorDetect().
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixMirrorDetectDwa/*"/>
/// <param name="pixs">[in] - 1 bpp, deskewed, English text</param>
/// <param name="pconf">[out] - confidence that text is not LR mirror reversed</param>
/// <param name="mincount">[in] - min number of left + right use 0 for default</param>
/// <param name="debug">[in] - 1 for debug output 0 otherwise</param>
/// <returns>0 if OK, 1 on error</returns>
public static int pixMirrorDetectDwa(
Pix pixs,
out Single pconf,
int mincount,
Enumerations.DebugOnOff debug = DebugOnOff.DebugOn)
{
if (pixs == null)
{
throw new ArgumentNullException("pixs cannot be Nothing");
}
int _Result = Natives.pixMirrorDetectDwa(pixs.Pointer, out pconf, mincount, (int)debug);
return(_Result);
}
// baseline.c (506, 1)
// pixGetLocalSkewAngles(pixs, nslices, redsweep, redsearch, sweeprange, sweepdelta, minbsdelta, pa, pb, debug) as Numa
// pixGetLocalSkewAngles(PIX *, l_int32, l_int32, l_int32, l_float32, l_float32, l_float32, l_float32 *, l_float32 *, l_int32) as NUMA *
/// <summary>
/// (1) The local skew is measured in a set of overlapping strips.
/// We then do a least square linear fit parameters to get
/// the slope and intercept parameters a and b in
/// skew-angle = a y + b (degrees)
/// for the local skew as a function of raster line y.
/// This is then used to make naskew, which can be interpreted
/// as the computed skew angle (in degrees) at the left edge
/// of each raster line.<para/>
///
/// (2) naskew can then be used to find the baselines of text, because
/// each text line has a baseline that should intersect
/// the left edge of the image with the angle given by this
/// array, evaluated at the raster line of intersection.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixGetLocalSkewAngles/*"/>
/// <param name="pixs">[in] - 1 bpp</param>
/// <param name="nslices">[in] - the number of horizontal overlapping slices must be larger than 1 and not exceed 20 0 for default</param>
/// <param name="redsweep">[in] - sweep reduction factor: 1, 2, 4 or 8 use 0 for default value</param>
/// <param name="redsearch">[in] - search reduction factor: 1, 2, 4 or 8, and not larger than redsweep use 0 for default value</param>
/// <param name="sweeprange">[in] - half the full range, assumed about 0 in degrees use 0.0 for default value</param>
/// <param name="sweepdelta">[in] - angle increment of sweep in degrees use 0.0 for default value</param>
/// <param name="minbsdelta">[in] - min binary search increment angle in degrees use 0.0 for default value</param>
/// <param name="pa">[out][optional] - slope of skew as fctn of y</param>
/// <param name="pb">[out][optional] - intercept at y=0 of skew as fctn of y</param>
/// <param name="debug">[in] - 1 for generating plot of skew angle vs. y 0 otherwise</param>
/// <returns>naskew, or NULL on error</returns>
public static Numa pixGetLocalSkewAngles(
Pix pixs,
int nslices,
int redsweep,
int redsearch,
Single sweeprange,
Single sweepdelta,
Single minbsdelta,
out Single pa,
out Single pb,
Enumerations.DebugOnOff debug = DebugOnOff.DebugOn)
{
if (pixs == null)
{
throw new ArgumentNullException("pixs cannot be Nothing");
}
if ((new List <int> {
1
}).Contains((int)pixs.d) == false)
{
throw new ArgumentException("1 bpp");
}
if ((new List <int> {
0, 1, 2, 4, 8
}).Contains((int)redsweep) == false)
{
throw new ArgumentException("sweep reduction factor: 1, 2, 4 or 8 use 0 for default value");
}
;
if ((new List <int> {
0, 1, 2, 4, 8
}).Contains((int)redsearch) == false)
{
throw new ArgumentException("search reduction factor: 1, 2, 4 or 8, and not larger than redsweep use 0 for default value");
}
;
IntPtr _Result = Natives.pixGetLocalSkewAngles(pixs.Pointer, nslices, redsweep, redsearch, sweeprange, sweepdelta, minbsdelta, out pa, out pb, (int)debug);
if (_Result == IntPtr.Zero)
{
return(null);
}
return(new Numa(_Result));
}
// colorcontent.c (1145, 1)
// pixColorsForQuantization(pixs, thresh, pncolors, piscolor, debug) as int
// pixColorsForQuantization(PIX *, l_int32, l_int32 *, l_int32 *, l_int32) as l_ok
/// <summary>
/// (1) This function finds a measure of the number of colors that are
/// found in low-gradient regions of an image. By its
/// magnitude relative to some threshold (not specified in
/// this function), it gives a good indication of whether
/// quantization will generate posterization. This number
/// is larger for images with regions of slowly varying
/// intensity (if 8 bpp) or color (if rgb). Such images, if
/// quantized, may require dithering to avoid posterization,
/// and lossless compression is then expected to be poor.<para/>
///
/// (2) If pixs has a colormap, the number of colors returned is
/// the number in the colormap.<para/>
///
/// (3) It is recommended that document images be reduced to a width
/// of 800 pixels before applying this function. Then it can
/// be expected that color detection will be fairly accurate
/// and the number of colors will reflect both the content and
/// the type of compression to be used. For less than 15 colors,
/// there is unlikely to be a halftone image, and lossless
/// quantization should give both a good visual result and
/// better compression.<para/>
///
/// (4) When using the default threshold on the gradient (15),
/// images (both gray and rgb) where ncolors is greater than
/// about 15 will compress poorly with either lossless
/// compression or dithered quantization, and they may be
/// posterized with non-dithered quantization.<para/>
///
/// (5) For grayscale images, or images without significant color,
/// this returns the number of significant gray levels in
/// the low-gradient regions. The actual number of gray levels
/// can be large due to jpeg compression noise in the background.<para/>
///
/// (6) Similarly, for color images, the actual number of different
/// (r,g,b) colors in the low-gradient regions (rather than the
/// number of occupied level 4 octcubes) can be quite large, e.g.,
/// due to jpeg compression noise, even for regions that appear
/// to be of a single color. By quantizing to level 4 octcubes,
/// most of these superfluous colors are removed from the counting.<para/>
///
/// (7) The image is tested for color. If there is very little color,
/// it is thresholded to gray and the number of gray levels in
/// the low gradient regions is found. If the image has color,
/// the number of occupied level 4 octcubes is found.<para/>
///
/// (8) The number of colors in the low-gradient regions increases
/// monotonically with the threshold %thresh on the edge gradient.<para/>
///
/// (9) Background: grayscale and color quantization is often useful
/// to achieve highly compressed images with little visible
/// distortion. However, gray or color washes (regions of
/// low gradient) can defeat this approach to high compression.
/// How can one determine if an image is expected to compress
/// well using gray or color quantization? We use the fact that
/// gray washes, when quantized with less than 50 intensities,
/// have posterization (visible boundaries between regions
/// of uniform 'color') and poor lossless compression
/// color washes, when quantized with level 4 octcubes,
/// typically result in both posterization and the occupancy
/// of many level 4 octcubes.
/// Images can have colors either intrinsically or as jpeg
/// compression artifacts. This function reduces but does not
/// completely eliminate measurement of jpeg quantization noise
/// in the white background of grayscale or color images.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixColorsForQuantization/*"/>
/// <param name="pixs">[in] - 8 bpp gray or 32 bpp rgb with or without colormap</param>
/// <param name="thresh">[in] - binary threshold on edge gradient 0 for default</param>
/// <param name="pncolors">[out] - the number of colors found</param>
/// <param name="piscolor">[out][optional] - 1 if significant color is found 0 otherwise. If pixs is 8 bpp, and does not have a colormap with color entries, this is 0</param>
/// <param name="debug">[in] - 1 to output masked image that is tested for colors 0 otherwise</param>
/// <returns>0 if OK, 1 on error.</returns>
public static int pixColorsForQuantization(
Pix pixs,
int thresh,
out int pncolors,
out int piscolor,
Enumerations.DebugOnOff debug = DebugOnOff.DebugOn)
{
if (pixs == null)
{
throw new ArgumentNullException("pixs cannot be Nothing");
}
int _Result = Natives.pixColorsForQuantization(pixs.Pointer, thresh, out pncolors, out piscolor, (int)debug);
return(_Result);
}
// recogtrain.c (352, 1)
// recogAddSample(recog, pix, debug) as int
// recogAddSample(L_RECOG *, PIX *, l_int32) as l_ok
/// <summary>
/// (1) The pix is 1 bpp, with the character string label embedded.<para/>
///
/// (2) The pixaa_u array of the recog is initialized to accept
/// up to 256 different classes. When training is finished,
/// the arrays are truncated to the actual number of classes.
/// To pad an existing recog from the boot recognizers, training
/// is started again if samples from a new class are added,
/// the pixaa_u array is extended by adding a pixa to hold them.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/recogAddSample/*"/>
/// <param name="recog">[in] - </param>
/// <param name="pix">[in] - a single character, 1 bpp</param>
/// <param name="debug">[in] - </param>
/// <returns>0 if OK, 1 on error</returns>
public static int recogAddSample(
L_Recog recog,
Pix pix,
Enumerations.DebugOnOff debug = DebugOnOff.DebugOn)
{
if (recog == null)
{
throw new ArgumentNullException("recog cannot be Nothing");
}
if (pix == null)
{
throw new ArgumentNullException("pix cannot be Nothing");
}
int _Result = Natives.recogAddSample(recog.Pointer, pix.Pointer, (int)debug);
return(_Result);
}
// dewarp4.c (223, 1)
// dewarpSinglePageRun(pixs, pixb, dewa, ppixd, debug) as int
// dewarpSinglePageRun(PIX *, PIX *, L_DEWARPA *, PIX **, l_int32) as l_ok
/// <summary>
/// (1) Dewarps pixs and returns the result in [and]pixd.<para/>
///
/// (2) The 1 bpp version %pixb and %dewa are conveniently generated by
/// dewarpSinglePageInit().<para/>
///
/// (3) Non-default model parameters must be set before calling this.<para/>
///
/// (4) If a model cannot be built, this returns a copy of pixs in [and]pixd.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/dewarpSinglePageRun/*"/>
/// <param name="pixs">[in] - any depth</param>
/// <param name="pixb">[in] - 1 bpp</param>
/// <param name="dewa">[in] - initialized</param>
/// <param name="ppixd">[out] - dewarped result</param>
/// <param name="debug">[in] - 1 for debugging output, 0 otherwise</param>
/// <returns>0 if OK, 1 on error list of page numbers, or NULL on error</returns>
public static int dewarpSinglePageRun(
Pix pixs,
Pix pixb,
L_Dewarpa dewa,
out Pix ppixd,
Enumerations.DebugOnOff debug = DebugOnOff.DebugOn)
{
if (pixs == null)
{
throw new ArgumentNullException("pixs cannot be Nothing");
}
if (pixb == null)
{
throw new ArgumentNullException("pixb cannot be Nothing");
}
if (dewa == null)
{
throw new ArgumentNullException("dewa cannot be Nothing");
}
if ((new List <int> {
1
}).Contains((int)pixb.d) == false)
{
throw new ArgumentException("1 bpp");
}
IntPtr ppixdPtr = IntPtr.Zero;
int _Result = Natives.dewarpSinglePageRun(pixs.Pointer, pixb.Pointer, dewa.Pointer, out ppixdPtr, (int)debug);
if (ppixdPtr == IntPtr.Zero)
{
ppixd = null;
}
else
{
ppixd = new Pix(ppixdPtr);
};
return(_Result);
}
// recogident.c (246, 1)
// recogSplitIntoCharacters(recog, pixs, minh, skipsplit, pboxa, ppixa, debug) as int
// recogSplitIntoCharacters(L_RECOG *, PIX *, l_int32, l_int32, BOXA **, PIXA **, l_int32) as l_ok
/// <summary>
/// (1) This can be given an image that has an arbitrary number
/// of text characters. It optionally splits connected
/// components based on document image decoding in recogDecode().
/// The returned pixa includes the boxes from which the
/// (possibly split) components are extracted.<para/>
///
/// (2) After noise filtering, the resulting components are put in
/// row-major (2D) order, and the smaller of overlapping
/// components are removed if they satisfy conditions of
/// relative size and fractional overlap.<para/>
///
/// (3) Note that the splitting function uses unscaled templates
/// and does not bother returning the class results and scores.
/// These are more accurately found later using the scaled templates.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/recogSplitIntoCharacters/*"/>
/// <param name="recog">[in] - </param>
/// <param name="pixs">[in] - 1 bpp, contains only mostly deskewed text</param>
/// <param name="minh">[in] - remove shorter components use 0 for default</param>
/// <param name="skipsplit">[in] - 1 to skip the splitting step</param>
/// <param name="pboxa">[out] - character bounding boxes</param>
/// <param name="ppixa">[out] - character images</param>
/// <param name="debug">[in] - 1 for results written to pixadb_split</param>
/// <returns>0 if OK, 1 on error or if no components are returned</returns>
public static int recogSplitIntoCharacters(
L_Recog recog,
Pix pixs,
int minh,
int skipsplit,
out Boxa pboxa,
out Pixa ppixa,
Enumerations.DebugOnOff debug = DebugOnOff.DebugOn)
{
if (recog == null)
{
throw new ArgumentNullException("recog cannot be Nothing");
}
if (pixs == null)
{
throw new ArgumentNullException("pixs cannot be Nothing");
}
IntPtr pboxaPtr = IntPtr.Zero;
IntPtr ppixaPtr = IntPtr.Zero;
int _Result = Natives.recogSplitIntoCharacters(recog.Pointer, pixs.Pointer, minh, skipsplit, out pboxaPtr, out ppixaPtr, (int)debug);
if (pboxaPtr == IntPtr.Zero)
{
pboxa = null;
}
else
{
pboxa = new Boxa(pboxaPtr);
};
if (ppixaPtr == IntPtr.Zero)
{
ppixa = null;
}
else
{
ppixa = new Pixa(ppixaPtr);
};
return(_Result);
}
// strokes.c (208, 1)
// pixaFindStrokeWidth(pixa, thresh, tab8, debug) as Numa
// pixaFindStrokeWidth(PIXA *, l_float32, l_int32 *, l_int32) as NUMA *
/// <summary>
/// (1) See pixFindStrokeWidth() for details.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixaFindStrokeWidth/*"/>
/// <param name="pixa">[in] - of 1 bpp images</param>
/// <param name="thresh">[in] - fractional count threshold relative to distance 1</param>
/// <param name="tab8">[in][optional] - table for counting fg pixels can be NULL</param>
/// <param name="debug">[in] - 1 for debug output 0 to skip</param>
/// <returns>na array of stroke widths for each pix in %pixa NULL on error</returns>
public static Numa pixaFindStrokeWidth(
Pixa pixa,
Single thresh,
int[] tab8 = null,
Enumerations.DebugOnOff debug = DebugOnOff.DebugOn)
{
if (pixa == null)
{
throw new ArgumentNullException("pixa cannot be Nothing");
}
IntPtr _Result = Natives.pixaFindStrokeWidth(pixa.Pointer, thresh, tab8, (int)debug);
if (_Result == IntPtr.Zero)
{
return(null);
}
return(new Numa(_Result));
}
// jp2kiostub.c (47, 7)
// pixReadJp2k(filename, reduction, box, hint, debug) as Pix
// pixReadJp2k(const char *, l_uint32, BOX *, l_int32, l_int32) as PIX *
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixReadJp2k/*"/>
/// <returns></returns>
public static Pix pixReadJp2k(
String filename,
uint reduction,
Box box,
int hint,
Enumerations.DebugOnOff debug)
{
if (filename == null)
{
throw new ArgumentNullException("filename cannot be Nothing");
}
if (box == null)
{
throw new ArgumentNullException("box cannot be Nothing");
}
if (File.Exists(filename) == false)
{
throw new ArgumentException("File is missing");
}
;
if (reduction < 2 || reduction > 16)
{
throw new ArgumentException("");
}
IntPtr boxPtr = IntPtr.Zero; if (box != null)
{
boxPtr = box.Pointer;
}
IntPtr _Result = Natives.pixReadJp2k(filename, reduction, box.Pointer, hint, (int)debug);
if (_Result == IntPtr.Zero)
{
return(null);
}
return(new Pix(_Result));
}
// recogtrain.c (486, 1)
// recogAverageSamples(precog, debug) as int
// recogAverageSamples(L_RECOG **, l_int32) as l_int32
/// <summary>
/// (1) This is only called in two situations:
/// (a) When splitting characters using either the DID method
/// recogDecode() or the the greedy splitter
/// recogCorrelationBestRow()
/// (b) By a special recognizer that is used to remove outliers.
/// Both unscaled and scaled inputs are averaged.<para/>
///
/// (2) If the data in any class is nonexistent (no samples), or
/// very bad (no fg pixels in the average), or if the ratio
/// of max/min average unscaled class template heights is
/// greater than max_ht_ratio, this destroys the recog.
/// The caller must check the return value of the recog.<para/>
///
/// (3) Set debug = 1 to view the resulting templates and their centroids.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/recogAverageSamples/*"/>
/// <param name="precog">[in] - addr of existing recog may be destroyed</param>
/// <param name="debug">[in] - </param>
/// <returns>0 on success, 1 on failure</returns>
public static int recogAverageSamples(
ref L_Recog precog,
Enumerations.DebugOnOff debug = DebugOnOff.DebugOn)
{
IntPtr precogPtr = IntPtr.Zero; if (precog != null)
{
precogPtr = precog.Pointer;
}
int _Result = Natives.recogAverageSamples(ref precogPtr, (int)debug);
if (precogPtr == IntPtr.Zero)
{
precog = null;
}
else
{
precog = new L_Recog(precogPtr);
};
return(_Result);
}
// jp2kiostub.c (55, 7)
// pixReadStreamJp2k(fp, reduction, box, hint, debug) as Pix
// pixReadStreamJp2k(FILE *, l_uint32, BOX *, l_int32, l_int32) as PIX *
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixReadStreamJp2k/*"/>
/// <returns></returns>
public static Pix pixReadStreamJp2k(
FILE fp,
uint reduction,
Box box,
int hint,
Enumerations.DebugOnOff debug)
{
if (fp == null)
{
throw new ArgumentNullException("fp cannot be Nothing");
}
if (box == null)
{
throw new ArgumentNullException("box cannot be Nothing");
}
if (reduction < 2 || reduction > 16)
{
throw new ArgumentException("");
}
IntPtr fpPtr = IntPtr.Zero; if (fp != null)
{
fpPtr = fp.Pointer;
}
IntPtr boxPtr = IntPtr.Zero; if (box != null)
{
boxPtr = box.Pointer;
}
IntPtr _Result = Natives.pixReadStreamJp2k(fp.Pointer, reduction, box.Pointer, hint, (int)debug);
if (_Result == IntPtr.Zero)
{
return(null);
}
return(new Pix(_Result));
}
// pixlabel.c (351, 1)
// pixConnCompIncrAdd(pixs, ptaa, pncc, x, y, debug) as int
// pixConnCompIncrAdd(PIX *, PTAA *, l_int32 *, l_float32, l_float32, l_int32) as l_int32
/// <summary>
/// (1) This adds a pixel and updates the labeled connected components.
/// Before calling this function, initialize the process using
/// pixConnCompIncrInit().<para/>
///
/// (2) As a result of adding a pixel, one of the following can happen,
/// depending on the number of neighbors with non-zero value:
/// (a) nothing: the pixel is already a member of a c.c.
/// (b) no neighbors: a new component is added, increasing the
/// number of c.c.
/// (c) one neighbor: the pixel is added to an existing c.c.
/// (d) more than one neighbor: the added pixel causes joining of
/// two or more c.c., reducing the number of c.c. A maximum
/// of 4 c.c. can be joined.<para/>
///
/// (3) When two c.c. are joined, the pixels in the larger index are
/// relabeled to those of the smaller in pixs, and their locations
/// are transferred to the pta with the smaller index in the ptaa.
/// The pta corresponding to the larger index is then deleted.<para/>
///
/// (4) This is an efficient implementation of a "union-find" operation,
/// which supports the generation and merging of disjoint sets
/// of pixels. This function can be called about 1.3 million times
/// per second.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixConnCompIncrAdd/*"/>
/// <param name="pixs">[in] - 32 bpp, with pixels labeled by c.c.</param>
/// <param name="ptaa">[in] - with each pta of pixel locations indexed by c.c.</param>
/// <param name="pncc">[out] - number of c.c</param>
/// <param name="x">[in] - ,y location of added pixel</param>
/// <param name="debug">[in] - 0 for no output otherwise output whenever debug smaller or equal nvals, up to debug == 3</param>
/// <returns>-1 if nothing happens 0 if a pixel is added 1 on error</returns>
public static int pixConnCompIncrAdd(
Pix pixs,
Ptaa ptaa,
out int pncc,
Single x,
Single y,
Enumerations.DebugOnOff debug = DebugOnOff.DebugOn)
{
if (pixs == null)
{
throw new ArgumentNullException("pixs cannot be Nothing");
}
if (ptaa == null)
{
throw new ArgumentNullException("ptaa cannot be Nothing");
}
int _Result = Natives.pixConnCompIncrAdd(pixs.Pointer, ptaa.Pointer, out pncc, x, y, (int)debug);
return(_Result);
}
// pageseg.c (264, 1)
// pixGenHalftoneMask(pixs, ppixtext, phtfound, debug) as Pix
// pixGenHalftoneMask(PIX *, PIX **, l_int32 *, l_int32) as PIX *
/// <summary>
/// Deprecated:
/// This wrapper avoids an ABI change with tesseract 3.0.4.
/// It should be removed when we no longer need to support 3.0.4.
/// The debug parameter is ignored (assumed 0).
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixGenHalftoneMask/*"/>
/// <returns></returns>
public static Pix pixGenHalftoneMask(
Pix pixs,
Pix ppixtext,
object phtfound,
Enumerations.DebugOnOff debug)
{
if (pixs == null)
{
throw new ArgumentNullException("pixs cannot be Nothing");
}
if (ppixtext == null)
{
throw new ArgumentNullException("ppixtext cannot be Nothing");
}
if (phtfound == null)
{
throw new ArgumentNullException("phtfound cannot be Nothing");
}
IntPtr pixsPtr = IntPtr.Zero; if (pixs != null)
{
pixsPtr = pixs.Pointer;
}
IntPtr ppixtextPtr = IntPtr.Zero; if (ppixtext != null)
{
ppixtextPtr = ppixtext.Pointer;
}
IntPtr _Result = Natives.pixGenHalftoneMask(pixs.Pointer, ppixtextPtr, phtfound, (int)debug);
if (_Result == IntPtr.Zero)
{
return(null);
}
return(new Pix(_Result));
}
// dewarp4.c (97, 1)
// dewarpSinglePage(pixs, thresh, adaptive, useboth, check_columns, ppixd, pdewa, debug) as int
// dewarpSinglePage(PIX *, l_int32, l_int32, l_int32, l_int32, PIX **, L_DEWARPA **, l_int32) as l_ok
/// <summary>
/// (1) Dewarps pixs and returns the result in [and]pixd.<para/>
///
/// (2) This uses default values for all model parameters.<para/>
///
/// (3) If pixs is 1 bpp, the parameters %adaptive and %thresh are ignored.<para/>
///
/// (4) If it can't build a model, returns a copy of pixs in [and]pixd.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/dewarpSinglePage/*"/>
/// <param name="pixs">[in] - with text, any depth</param>
/// <param name="thresh">[in] - for global thresholding to 1 bpp ignored otherwise</param>
/// <param name="adaptive">[in] - 1 for adaptive thresholding 0 for global threshold</param>
/// <param name="useboth">[in] - 1 for horizontal and vertical 0 for vertical only</param>
/// <param name="check_columns">[in] - 1 to skip horizontal if multiple columns 0 otherwise default is to skip</param>
/// <param name="ppixd">[out] - dewarped result</param>
/// <param name="pdewa">[out][optional] - dewa with single page NULL to skip</param>
/// <param name="debug">[in] - 1 for debugging output, 0 otherwise</param>
/// <returns>0 if OK, 1 on error list of page numbers, or NULL on error</returns>
public static int dewarpSinglePage(
Pix pixs,
int thresh,
int adaptive,
int useboth,
int check_columns,
out Pix ppixd,
out L_Dewarpa pdewa,
Enumerations.DebugOnOff debug = DebugOnOff.DebugOn)
{
if (pixs == null)
{
throw new ArgumentNullException("pixs cannot be Nothing");
}
IntPtr ppixdPtr = IntPtr.Zero;
IntPtr pdewaPtr = IntPtr.Zero;
int _Result = Natives.dewarpSinglePage(pixs.Pointer, thresh, adaptive, useboth, check_columns, out ppixdPtr, out pdewaPtr, (int)debug);
if (ppixdPtr == IntPtr.Zero)
{
ppixd = null;
}
else
{
ppixd = new Pix(ppixdPtr);
};
if (pdewaPtr == IntPtr.Zero)
{
pdewa = null;
}
else
{
pdewa = new L_Dewarpa(pdewaPtr);
};
return(_Result);
}
// flipdetect.c (242, 1)
// pixOrientCorrect(pixs, minupconf, minratio, pupconf, pleftconf, protation, debug) as Pix
// pixOrientCorrect(PIX *, l_float32, l_float32, l_float32 *, l_float32 *, l_int32 *, l_int32) as PIX *
/// <summary>
/// (1) Simple top-level function to detect if Roman text is in
/// reading orientation, and to rotate the image accordingly if not.<para/>
///
/// (2) Returns a copy if no rotation is needed.<para/>
///
/// (3) See notes for pixOrientDetect() and pixOrientDecision().
/// Use 0.0 for default values for %minupconf and %minratio<para/>
///
/// (4) Optional output of intermediate confidence results and
/// the rotation performed on pixs.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixOrientCorrect/*"/>
/// <param name="pixs">[in] - 1 bpp, deskewed, English text, 150 - 300 ppi</param>
/// <param name="minupconf">[in] - minimum value for which a decision can be made</param>
/// <param name="minratio">[in] - minimum conf ratio required for a decision</param>
/// <param name="pupconf">[out][optional] - use NULL to skip</param>
/// <param name="pleftconf">[out][optional] - use NULL to skip</param>
/// <param name="protation">[out][optional] - use NULL to skip</param>
/// <param name="debug">[in] - 1 for debug output 0 otherwise</param>
/// <returns>pixd may be rotated by 90, 180 or 270 null on error</returns>
public static Pix pixOrientCorrect(
Pix pixs,
Single minupconf,
Single minratio,
out Single pupconf,
out Single pleftconf,
out int protation,
Enumerations.DebugOnOff debug = DebugOnOff.DebugOn)
{
if (pixs == null)
{
throw new ArgumentNullException("pixs cannot be Nothing");
}
IntPtr _Result = Natives.pixOrientCorrect(pixs.Pointer, minupconf, minratio, out pupconf, out pleftconf, out protation, (int)debug);
if (_Result == IntPtr.Zero)
{
return(null);
}
return(new Pix(_Result));
}
// jp2kiostub.c (79, 7)
// pixReadMemJp2k(data, size, reduction, box, hint, debug) as Pix
// pixReadMemJp2k(const l_uint8 *, size_t, l_uint32, BOX *, l_int32, l_int32) as PIX *
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/pixReadMemJp2k/*"/>
/// <returns></returns>
public static Pix pixReadMemJp2k(
Byte[] data,
uint size,
uint reduction,
Box box,
int hint,
Enumerations.DebugOnOff debug)
{
if (data == null)
{
throw new ArgumentNullException("data cannot be Nothing");
}
if (box == null)
{
throw new ArgumentNullException("box cannot be Nothing");
}
if (reduction < 2 || reduction > 16)
{
throw new ArgumentException("");
}
IntPtr boxPtr = IntPtr.Zero; if (box != null)
{
boxPtr = box.Pointer;
}
IntPtr _Result = Natives.pixReadMemJp2k(data, size, reduction, box.Pointer, hint, (int)debug);
if (_Result == IntPtr.Zero)
{
return(null);
}
return(new Pix(_Result));
}
