public static int dewarpWriteMem(out IntPtr pdata, IntPtr psize, L_Dewarp dew)
{
if (IntPtr.Zero == psize ||
null == dew)
{
throw new ArgumentNullException("psize, dew cannot be null.");
}
return(Native.DllImports.dewarpWriteMem(out pdata, psize, (HandleRef)dew));
}
public static int dewarpWriteStream(IntPtr fp, L_Dewarp dew)
{
if (IntPtr.Zero == fp ||
null == dew)
{
throw new ArgumentNullException("fp, dew cannot be null.");
}
return(Native.DllImports.dewarpWriteStream(fp, (HandleRef)dew));
}
public static int dewarpWrite(string filename, L_Dewarp dew)
{
if (null == dew ||
string.IsNullOrWhiteSpace(filename))
{
throw new ArgumentNullException("filename, dewa cannot be null.");
}
return(Native.DllImports.dewarpWrite(filename, (HandleRef)dew));
}
public static void dewarpDestroy(this L_Dewarp pdew)
{
if (null == pdew)
{
throw new ArgumentNullException("pdew cannot be null");
}
var pointer = (IntPtr)pdew;
Native.DllImports.dewarpDestroy(ref pointer);
}
// dewarp3.c (729, 1)
// dewarpMinimize(dew) as int
// dewarpMinimize(L_DEWARP *) as l_ok
/// <summary>
/// (1) This removes all data that is not needed for serialization.
/// It keeps the subsampled disparity array(s), so the full
/// resolution arrays can be reconstructed.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/dewarpMinimize/*"/>
/// <param name="dew">[in] - </param>
/// <returns>0 if OK, 1 on error</returns>
public static int dewarpMinimize(
L_Dewarp dew)
{
if (dew == null)
{
throw new ArgumentNullException("dew cannot be Nothing");
}
int _Result = Natives.dewarpMinimize(dew.Pointer);
return(_Result);
}
// Dewarpa insertion/extraction
public static int dewarpaInsertDewarp(this L_Dewarpa dewa, L_Dewarp dew)
{
if (null == dewa ||
null == dew)
{
throw new ArgumentNullException("dewa, dew cannot be null");
}
var pointer = (IntPtr)dewa;
return(Native.DllImports.dewarpaInsertDewarp((HandleRef)dewa, (HandleRef)dew));
}
// dewarp2.c (148, 1)
// dewarpBuildPageModel(dew, debugfile) as int
// dewarpBuildPageModel(L_DEWARP *, const char *) as l_ok
/// <summary>
/// (1) This is the basic function that builds the horizontal and
/// vertical disparity arrays, which allow determination of the
/// src pixel in the input image corresponding to each
/// dest pixel in the dewarped image.<para/>
///
/// (2) Sets vsuccess = 1 if the vertical disparity array builds.
/// Always attempts to build the horizontal disparity array,
/// even if it will not be requested (useboth == 0).
/// Sets hsuccess = 1 if horizontal disparity builds.<para/>
///
/// (3) The method is as follows:
/// (a) Estimate the points along the centers of all the
/// long textlines. If there are too few lines, no
/// disparity models are built.
/// (b) From the vertical deviation of the lines, estimate
/// the vertical disparity.
/// (c) From the ends of the lines, estimate the horizontal
/// disparity, assuming that the text is made of lines
/// that are close to left and right justified.
/// (d) One can also compute an additional contribution to the
/// horizontal disparity, inferred from slopes of the top
/// and bottom lines. We do not do this.<para/>
///
/// (4) In more detail for the vertical disparity:
/// (a) Fit a LS quadratic to center locations along each line.
/// This smooths the curves.
/// (b) Sample each curve at a regular interval, find the y-value
/// of the mid-point on each curve, and subtract the sampled
/// curve value from this value. This is the vertical
/// disparity at sampled points along each curve.
/// (c) Fit a LS quadratic to each set of vertically aligned
/// disparity samples. This smooths the disparity values
/// in the vertical direction. Then resample at the same
/// regular interval. We now have a regular grid of smoothed
/// vertical disparity valuels.<para/>
///
/// (5) Once the sampled vertical disparity array is found, it can be
/// interpolated to get a full resolution vertical disparity map.
/// This can be applied directly to the src image pixels
/// to dewarp the image in the vertical direction, making
/// all textlines horizontal. Likewise, the horizontal
/// disparity array is used to left- and right-align the
/// longest textlines.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/dewarpBuildPageModel/*"/>
/// <param name="dew">[in] - </param>
/// <param name="debugfile">[in]use NULL to skip - writing this</param>
/// <returns>0 if OK, 1 if unable to build the model or on error</returns>
public static int dewarpBuildPageModel(
L_Dewarp dew,
String debugfile = "")
{
if (dew == null)
{
throw new ArgumentNullException("dew cannot be Nothing");
}
int _Result = Natives.dewarpBuildPageModel(dew.Pointer, debugfile);
return(_Result);
}
// dewarp1.c (1330, 1)
// dewarpWriteStream(fp, dew) as int
// dewarpWriteStream(FILE *, L_DEWARP *) as l_ok
/// <summary>
/// (1) This should not be written if there is no sampled
/// vertical disparity array, which means that no model has
/// been built for this page.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/dewarpWriteStream/*"/>
/// <param name="fp">[in] - file stream opened for "wb"</param>
/// <param name="dew">[in] - </param>
/// <returns>0 if OK, 1 on error</returns>
public static int dewarpWriteStream(
FILE fp,
L_Dewarp dew)
{
if (fp == null)
{
throw new ArgumentNullException("fp cannot be Nothing");
}
if (dew == null)
{
throw new ArgumentNullException("dew cannot be Nothing");
}
int _Result = Natives.dewarpWriteStream(fp.Pointer, dew.Pointer);
return(_Result);
}
// dewarp1.c (1292, 1)
// dewarpWrite(filename, dew) as int
// dewarpWrite(const char *, L_DEWARP *) as l_ok
/// <summary>
/// dewarpWrite()
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/dewarpWrite/*"/>
/// <param name="filename">[in] - </param>
/// <param name="dew">[in] - </param>
/// <returns>0 if OK, 1 on error</returns>
public static int dewarpWrite(
String filename,
L_Dewarp dew)
{
if (filename == null)
{
throw new ArgumentNullException("filename cannot be Nothing");
}
if (dew == null)
{
throw new ArgumentNullException("dew cannot be Nothing");
}
int _Result = Natives.dewarpWrite(filename, dew.Pointer);
return(_Result);
}
// dewarp1.c (805, 1)
// dewarpaInsertDewarp(dewa, dew) as int
// dewarpaInsertDewarp(L_DEWARPA *, L_DEWARP *) as l_ok
/// <summary>
/// (1) This inserts the dewarp into the array, which now owns it.
/// It also keeps track of the largest page number stored.
/// It must be done before the disparity model is built.<para/>
///
/// (2) Note that this differs from the usual method of filling out
/// arrays in leptonica, where the arrays are compact and
/// new elements are typically added to the end. Here,
/// the dewarp can be added anywhere, even beyond the initial
/// allocation.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/dewarpaInsertDewarp/*"/>
/// <param name="dewa">[in] - </param>
/// <param name="dew">[in] - to be added</param>
/// <returns>0 if OK, 1 on error</returns>
public static int dewarpaInsertDewarp(
L_Dewarpa dewa,
L_Dewarp dew)
{
if (dewa == null)
{
throw new ArgumentNullException("dewa cannot be Nothing");
}
if (dew == null)
{
throw new ArgumentNullException("dew cannot be Nothing");
}
int _Result = Natives.dewarpaInsertDewarp(dewa.Pointer, dew.Pointer);
return(_Result);
}
// dewarp2.c (558, 1)
// dewarpFindHorizDisparity(dew, ptaa) as int
// dewarpFindHorizDisparity(L_DEWARP *, PTAA *) as l_ok
/// <summary>
/// (1) This builds a horizontal disparity model (HDM), but
/// does not check it against constraints for validity.
/// Constraint checking is done at rendering time.<para/>
///
/// (2) Horizontal disparity is not required for a successful model
/// only the vertical disparity is required. This will not be
/// called if the function to build the vertical disparity fails.<para/>
///
/// (3) This sets the hsuccess flag to 1 on success.<para/>
///
/// (4) Internally in ptal1, ptar1, ptal2, ptar2: x and y are reversed,
/// so the 'y' value is horizontal distance across the image width.<para/>
///
/// (5) Debug output goes to /tmp/lept/dewmod/ for collection into a pdf.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/dewarpFindHorizDisparity/*"/>
/// <param name="dew">[in] - </param>
/// <param name="ptaa">[in] - unsmoothed lines, not vertically ordered</param>
/// <returns>0 if OK, 1 if horizontal disparity array is not built, or on error</returns>
public static int dewarpFindHorizDisparity(
L_Dewarp dew,
Ptaa ptaa)
{
if (dew == null)
{
throw new ArgumentNullException("dew cannot be Nothing");
}
if (ptaa == null)
{
throw new ArgumentNullException("ptaa cannot be Nothing");
}
int _Result = Natives.dewarpFindHorizDisparity(dew.Pointer, ptaa.Pointer);
return(_Result);
}
// dewarp3.c (785, 1)
// dewarpPopulateFullRes(dew, pix, x, y) as int
// dewarpPopulateFullRes(L_DEWARP *, PIX *, l_int32, l_int32) as l_ok
/// <summary>
/// (1) If the full resolution vertical and horizontal disparity
/// arrays do not exist, they are built from the subsampled ones.<para/>
///
/// (2) If pixs is not given, the size of the arrays is determined
/// by the original image from which the sampled version was
/// generated. Any values of (x,y) are ignored.<para/>
///
/// (3) If pixs is given, the full resolution disparity arrays must
/// be large enough to accommodate it.
/// (a) If the arrays do not exist, the value of (x,y) determines
/// the origin of the full resolution arrays without extension,
/// relative to pixs. Thus, (x,y) gives the amount of
/// slope extension in (left, top). The (right, bottom)
/// extension is then determined by the size of pixs and
/// (x,y) the values should never be is smaller 0.
/// (b) If the arrays exist and pixs is too large, the existing
/// full res arrays are destroyed and new ones are made,
/// again using (x,y) to determine the extension in the
/// four directions.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/dewarpPopulateFullRes/*"/>
/// <param name="dew">[in] - </param>
/// <param name="pix">[in][optional] - , to give size of actual image</param>
/// <param name="x">[in] - origin for generation of disparity arrays</param>
/// <param name="y">[in] - origin for generation of disparity arrays</param>
/// <returns>0 if OK, 1 on error</returns>
public static int dewarpPopulateFullRes(
L_Dewarp dew,
Pix pix,
int x,
int y)
{
if (dew == null)
{
throw new ArgumentNullException("dew cannot be Nothing");
}
IntPtr pixPtr = IntPtr.Zero; if (pix != null)
{
pixPtr = pix.Pointer;
}
int _Result = Natives.dewarpPopulateFullRes(dew.Pointer, pixPtr, x, y);
return(_Result);
}
// dewarp1.c (509, 1)
// dewarpDestroy(pdew) as Object
// dewarpDestroy(L_DEWARP **) as void
/// <summary>
/// dewarpDestroy()
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/dewarpDestroy/*"/>
/// <param name="pdew">[in,out] - will be set to null before returning</param>
public static void dewarpDestroy(
ref L_Dewarp pdew)
{
IntPtr pdewPtr = IntPtr.Zero; if (pdew != null)
{
pdewPtr = pdew.Pointer;
}
Natives.dewarpDestroy(ref pdewPtr);
if (pdewPtr == IntPtr.Zero)
{
pdew = null;
}
else
{
pdew = new L_Dewarp(pdewPtr);
};
}
// dewarp4.c (1008, 1)
// dewarpDebug(dew, subdirs, index) as int
// dewarpDebug(L_DEWARP *, const char *, l_int32) as l_ok
/// <summary>
/// (1) Prints dewarp fields and generates disparity array contour images.
/// The contour images are written to file:
/// /tmp/[subdirs]/pixv_[index].png
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/dewarpDebug/*"/>
/// <param name="dew">[in] - </param>
/// <param name="subdirs">[in] - one or more subdirectories of /tmp e.g., "dew1"</param>
/// <param name="index">[in] - to help label output images e.g., the page number</param>
/// <returns>0 if OK, 1 on error</returns>
public static int dewarpDebug(
L_Dewarp dew,
String subdirs,
int index)
{
if (dew == null)
{
throw new ArgumentNullException("dew cannot be Nothing");
}
if (subdirs == null)
{
throw new ArgumentNullException("subdirs cannot be Nothing");
}
int _Result = Natives.dewarpDebug(dew.Pointer, subdirs, index);
return(_Result);
}
// dewarp2.c (1378, 1)
// dewarpFindHorizSlopeDisparity(dew, pixb, fractthresh, parity) as int
// dewarpFindHorizSlopeDisparity(L_DEWARP *, PIX *, l_float32, l_int32) as l_ok
/// <summary>
/// (1) %fractthresh is a threshold on the fractional difference in stroke
/// density between between left and right sides. Process this
/// disparity only if the absolute value of the fractional
/// difference equals or exceeds this threshold.<para/>
///
/// (2) %parity indicates where the binding is: on the left for
/// %parity == 0 and on the right for %parity == 1.<para/>
///
/// (3) This takes a 1 bpp %pixb where both vertical and horizontal
/// disparity have been applied, so the text lines are straight and,
/// more importantly, the line end points are vertically aligned.
/// It estimates the foreshortening of the characters on the
/// binding side, and if significant, computes a one-dimensional
/// horizontal disparity function to compensate.<para/>
///
/// (4) The first attempt was to use the average width of the
/// connected components (c.c.) in vertical slices. This does not work
/// reliably, because the horizontal compression of the text is
/// often accompanied by horizontal joining of c.c.<para/>
///
/// (5) We use the density of vertical strokes, measured by first using
/// a vertical opening, which improves the signal. The result
/// is relatively insensitive to the size of the opening we use
/// a 10-pixel opening. The relative density is measured by
/// finding the number of c.c. in a full height sliding window
/// of width 50 pixels, and compute every 25 pixels. Similar results
/// are obtained counting c.c. that either intersect the window
/// or are fully contained within it.<para/>
///
/// (6) Debug output goes to /tmp/lept/dewmod/ for collection into a pdf.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/dewarpFindHorizSlopeDisparity/*"/>
/// <param name="dew">[in] - </param>
/// <param name="pixb">[in] - (1 bpp, with vertical and horizontal disparity removed)</param>
/// <param name="fractthresh">[in] - (threshold fractional difference in density)</param>
/// <param name="parity">[in] - (0 if even page, 1 if odd page)</param>
/// <returns>0 if OK, 1 on error</returns>
public static int dewarpFindHorizSlopeDisparity(
L_Dewarp dew,
Pix pixb,
Single fractthresh,
int parity)
{
if (dew == null)
{
throw new ArgumentNullException("dew cannot be Nothing");
}
if (pixb == null)
{
throw new ArgumentNullException("pixb cannot be Nothing");
}
int _Result = Natives.dewarpFindHorizSlopeDisparity(dew.Pointer, pixb.Pointer, fractthresh, parity);
return(_Result);
}
// dewarp1.c (1386, 1)
// dewarpWriteMem(pdata, psize, dew) as int
// dewarpWriteMem(l_uint8 **, size_t *, L_DEWARP *) as l_ok
/// <summary>
/// (1) Serializes a dewarp in memory and puts the result in a buffer.
/// </summary>
/// <remarks>
/// </remarks>
/// <include file="..\CHM_Help\IncludeComments.xml" path="Comments/dewarpWriteMem/*"/>
/// <param name="pdata">[out] - data of serialized dewarp (not ascii)</param>
/// <param name="psize">[out] - size of returned data</param>
/// <param name="dew">[in] - </param>
/// <returns>0 if OK, 1 on error</returns>
public static int dewarpWriteMem(
out Byte[] pdata,
out uint psize,
L_Dewarp dew)
{
if (dew == null)
{
throw new ArgumentNullException("dew cannot be Nothing");
}
IntPtr pdataPtr = IntPtr.Zero;
int _Result = Natives.dewarpWriteMem(out pdataPtr, out psize, dew.Pointer);
Byte[] pdataGen = new Byte[psize];
if (pdataPtr != IntPtr.Zero)
{
Marshal.Copy(pdataPtr, pdataGen, 0, pdataGen.Length);
}
pdata = pdataGen;
return(_Result);
}
