Package | Description |
---|---|
org.bytedeco.leptonica | |
org.bytedeco.leptonica.global |
Modifier and Type | Class and Description |
---|---|
protected static class |
AbstractPIX.DestroyDeallocator |
Modifier and Type | Method and Description |
---|---|
PIX |
AbstractPIX.clone()
Calls pixClone(), and registers a deallocator.
|
PIX |
PIX.colormap(PIXCMAP setter) |
static PIX |
AbstractPIX.create(int width,
int height,
int depth)
Calls pixCreate(), and registers a deallocator.
|
static PIX |
AbstractPIX.create(int width,
int height,
int depth,
Pointer data)
Calls createHeader(), and initializes data, keeping a reference to prevent deallocation.
|
static PIX |
AbstractPIX.createHeader(int width,
int height,
int depth)
Calls pixCreateHeader(), and registers a deallocator.
|
static PIX |
AbstractPIX.createNoInit(int width,
int height,
int depth)
Calls pixCreateNoInit(), and registers a deallocator.
|
static PIX |
AbstractPIX.createTemplate(PIX pixs)
Calls pixCreateTemplate(), and registers a deallocator.
|
static PIX |
AbstractPIX.createTemplateNoInit(PIX pixs)
Calls pixCreateTemplateNoInit(), and registers a deallocator.
|
PIX |
PIX.d(int setter) |
PIX |
PIX.data(IntPointer setter) |
PIX |
PIX.getPointer(long i) |
PIX |
PIX.h(int setter) |
PIX |
PIX.informat(int setter) |
PIX |
PIXTILING.pix()
input pix (a clone)
|
PIX |
CCBORDA.pix()
input pix (may be null)
|
PIX |
JBDATA.pix()
template composite for all classes
|
PIX |
CCBORD.pix()
component bitmap (min size)
|
PIX |
PIXACC.pix()
the 32 bit accumulator pix
|
PIX |
PIXA.pix(int i)
the array of ptrs to pix
|
PIX |
L_RECOG.pixdb_ave()
debug: best match of input against ave.
|
PIX |
L_RECOG.pixdb_range()
debug: best matches within range
|
PIX |
L_WSHED.pixlab()
16 bpp label pix
|
PIX |
L_WSHED.pixm()
clone of input 1 bpp seed (marker) pixm
|
PIX |
L_WSHED.pixs()
clone of input 8 bpp pixs
|
PIX |
L_COLORFILL.pixs()
clone of source pix
|
PIX |
L_DEWARP.pixs()
source pix, 1 bpp
|
PIX |
L_RDID.pixs()
clone of pix to be decoded
|
PIX |
L_COLORFILL.pixst()
source pix, after optional transform
|
PIX |
L_WSHED.pixt()
scratch pix for computing wshed regions
|
PIX |
PIX.position(long position) |
PIX |
PIX.refcount(int setter) |
PIX |
PIX.special(int setter) |
PIX |
PIX.spp(int setter) |
PIX |
PIX.text(BytePointer setter) |
PIX |
PIX.w(int setter) |
PIX |
PIX.wpl(int setter) |
PIX |
PIX.xres(int setter) |
PIX |
PIX.yres(int setter) |
Modifier and Type | Method and Description |
---|---|
static PIX |
AbstractPIX.createTemplate(PIX pixs)
Calls pixCreateTemplate(), and registers a deallocator.
|
static PIX |
AbstractPIX.createTemplateNoInit(PIX pixs)
Calls pixCreateTemplateNoInit(), and registers a deallocator.
|
PIXA |
PIXA.pix(int i,
PIX setter) |
PIXTILING |
PIXTILING.pix(PIX setter) |
CCBORDA |
CCBORDA.pix(PIX setter) |
JBDATA |
JBDATA.pix(PIX setter) |
CCBORD |
CCBORD.pix(PIX setter) |
PIXACC |
PIXACC.pix(PIX setter) |
L_RECOG |
L_RECOG.pixdb_ave(PIX setter) |
L_RECOG |
L_RECOG.pixdb_range(PIX setter) |
L_WSHED |
L_WSHED.pixlab(PIX setter) |
L_WSHED |
L_WSHED.pixm(PIX setter) |
L_WSHED |
L_WSHED.pixs(PIX setter) |
L_COLORFILL |
L_COLORFILL.pixs(PIX setter) |
L_DEWARP |
L_DEWARP.pixs(PIX setter) |
L_RDID |
L_RDID.pixs(PIX setter) |
L_COLORFILL |
L_COLORFILL.pixst(PIX setter) |
L_WSHED |
L_WSHED.pixt(PIX setter) |
Modifier and Type | Method and Description |
---|---|
static PIX |
lept.bmfGetPix(L_BMF bmf,
byte chr) |
static PIX |
lept.boxaaDisplay(PIX pixs,
BOXAA baa,
int linewba,
int linewb,
int colorba,
int colorb,
int w,
int h) |
static PIX |
lept.boxaDisplayTiled(BOXA boxas,
PIXA pixa,
int first,
int last,
int maxwidth,
int linewidth,
float scalefactor,
int background,
int spacing,
int border) |
static PIX |
lept.ccbaDisplayBorder(CCBORDA ccba) |
static PIX |
lept.ccbaDisplayImage1(CCBORDA ccba) |
static PIX |
lept.ccbaDisplayImage2(CCBORDA ccba) |
static PIX |
lept.ccbaDisplaySPBorder(CCBORDA ccba) |
static PIX |
lept.displayHSVColorRange(int hval,
int sval,
int vval,
int huehw,
int sathw,
int nsamp,
int factor) |
static PIX |
lept.dpixConvertToPix(DPIX dpixs,
int outdepth,
int negvals,
int errorflag) |
static PIX |
lept.fpixaConvertLABToRGB(FPIXA fpixa) |
static PIX |
lept.fpixaConvertXYZToRGB(FPIXA fpixa) |
static PIX |
lept.fpixaDisplayQuadtree(FPIXA fpixa,
int factor,
int fontsize) |
static PIX |
lept.fpixAutoRenderContours(FPIX fpix,
int ncontours) |
static PIX |
lept.fpixConvertToPix(FPIX fpixs,
int outdepth,
int negvals,
int errorflag) |
static PIX |
lept.fpixDisplayMaxDynamicRange(FPIX fpixs) |
static PIX |
lept.fpixRenderContours(FPIX fpixs,
float incr,
float proxim) |
static PIX |
lept.fpixThresholdToPix(FPIX fpix,
float thresh) |
static PIX |
lept.generateBinaryMaze(int w,
int h,
int xi,
int yi,
float wallps,
float ranis) |
static PIX |
lept.gplotGeneralPix1(NUMA na,
int plotstyle,
BytePointer rootname,
BytePointer title,
BytePointer xlabel,
BytePointer ylabel) |
static PIX |
lept.gplotGeneralPix1(NUMA na,
int plotstyle,
String rootname,
String title,
String xlabel,
String ylabel) |
static PIX |
lept.gplotGeneralPix2(NUMA na1,
NUMA na2,
int plotstyle,
BytePointer rootname,
BytePointer title,
BytePointer xlabel,
BytePointer ylabel) |
static PIX |
lept.gplotGeneralPix2(NUMA na1,
NUMA na2,
int plotstyle,
String rootname,
String title,
String xlabel,
String ylabel) |
static PIX |
lept.gplotGeneralPixN(NUMA nax,
NUMAA naay,
int plotstyle,
BytePointer rootname,
BytePointer title,
BytePointer xlabel,
BytePointer ylabel) |
static PIX |
lept.gplotGeneralPixN(NUMA nax,
NUMAA naay,
int plotstyle,
String rootname,
String title,
String xlabel,
String ylabel) |
static PIX |
lept.gplotMakeOutputPix(GPLOT gplot) |
static PIX |
lept.gplotSimplePix1(NUMA na,
BytePointer title) |
static PIX |
lept.gplotSimplePix1(NUMA na,
String title) |
static PIX |
lept.gplotSimplePix2(NUMA na1,
NUMA na2,
BytePointer title) |
static PIX |
lept.gplotSimplePix2(NUMA na1,
NUMA na2,
String title) |
static PIX |
lept.gplotSimplePixN(NUMAA naa,
BytePointer title) |
static PIX |
lept.gplotSimplePixN(NUMAA naa,
String title) |
static PIX |
lept.kernelDisplayInPix(L_KERNEL kel,
int size,
int gthick) |
static PIX |
lept.pixaaDisplay(PIXAA paa,
int w,
int h) |
static PIX |
lept.pixaaDisplayByPixa(PIXAA paa,
int maxnx,
float scalefactor,
int hspacing,
int vspacing,
int border) |
static PIX |
lept.pixaaGetPix(PIXAA paa,
int index,
int ipix,
int accessflag) |
static PIX |
lept.pixAbsDifference(PIX pixs1,
PIX pixs2) |
static PIX |
lept.pixaccFinal(PIXACC pixacc,
int outdepth) |
static PIX |
lept.pixaccGetPix(PIXACC pixacc) |
static PIX |
lept.pixacompDisplayTiledAndScaled(PIXAC pixac,
int outdepth,
int tilewidth,
int ncols,
int background,
int spacing,
int border) |
static PIX |
lept.pixacompGetPix(PIXAC pixac,
int index) |
static PIX |
lept.pixAdaptThresholdToBinary(PIX pixs,
PIX pixm,
float gamma) |
static PIX |
lept.pixAdaptThresholdToBinaryGen(PIX pixs,
PIX pixm,
float gamma,
int blackval,
int whiteval,
int thresh) |
static PIX |
lept.pixAddAlphaTo1bpp(PIX pixd,
PIX pixs) |
static PIX |
lept.pixAddAlphaToBlend(PIX pixs,
float fract,
int invert) |
static PIX |
lept.pixAddBlackOrWhiteBorder(PIX pixs,
int left,
int right,
int top,
int bot,
int op) |
static PIX |
lept.pixAddBorder(PIX pixs,
int npix,
int val) |
static PIX |
lept.pixAddBorderGeneral(PIX pixs,
int left,
int right,
int top,
int bot,
int val) |
static PIX |
lept.pixAddContinuedBorder(PIX pixs,
int left,
int right,
int top,
int bot) |
static PIX |
lept.pixAddGaussianNoise(PIX pixs,
float stdev) |
static PIX |
lept.pixAddGray(PIX pixd,
PIX pixs1,
PIX pixs2) |
static PIX |
lept.pixAddMinimalGrayColormap8(PIX pixs) |
static PIX |
lept.pixAddMirroredBorder(PIX pixs,
int left,
int right,
int top,
int bot) |
static PIX |
lept.pixAddMixedBorder(PIX pixs,
int left,
int right,
int top,
int bot) |
static PIX |
lept.pixAddRepeatedBorder(PIX pixs,
int left,
int right,
int top,
int bot) |
static PIX |
lept.pixAddRGB(PIX pixs1,
PIX pixs2) |
static PIX |
lept.pixAddSingleTextblock(PIX pixs,
L_BMF bmf,
BytePointer textstr,
int val,
int location,
int[] poverflow) |
static PIX |
lept.pixAddSingleTextblock(PIX pixs,
L_BMF bmf,
BytePointer textstr,
int val,
int location,
IntBuffer poverflow) |
static PIX |
lept.pixAddSingleTextblock(PIX pixs,
L_BMF bmf,
BytePointer textstr,
int val,
int location,
IntPointer poverflow) |
static PIX |
lept.pixAddSingleTextblock(PIX pixs,
L_BMF bmf,
String textstr,
int val,
int location,
int[] poverflow) |
static PIX |
lept.pixAddSingleTextblock(PIX pixs,
L_BMF bmf,
String textstr,
int val,
int location,
IntBuffer poverflow) |
static PIX |
lept.pixAddSingleTextblock(PIX pixs,
L_BMF bmf,
String textstr,
int val,
int location,
IntPointer poverflow) |
static PIX |
lept.pixAddTextlines(PIX pixs,
L_BMF bmf,
BytePointer textstr,
int val,
int location) |
static PIX |
lept.pixAddTextlines(PIX pixs,
L_BMF bmf,
String textstr,
int val,
int location) |
static PIX |
lept.pixaDisplay(PIXA pixa,
int w,
int h) |
static PIX |
lept.pixaDisplayLinearly(PIXA pixas,
int direction,
float scalefactor,
int background,
int spacing,
int border,
BOXA pboxa) |
static PIX |
lept.pixaDisplayLinearly(PIXA pixas,
int direction,
float scalefactor,
int background,
int spacing,
int border,
PointerPointer pboxa) |
static PIX |
lept.pixaDisplayOnLattice(PIXA pixa,
int cellw,
int cellh,
int[] pncols,
BOXA pboxa) |
static PIX |
lept.pixaDisplayOnLattice(PIXA pixa,
int cellw,
int cellh,
IntBuffer pncols,
BOXA pboxa) |
static PIX |
lept.pixaDisplayOnLattice(PIXA pixa,
int cellw,
int cellh,
IntPointer pncols,
BOXA pboxa) |
static PIX |
lept.pixaDisplayOnLattice(PIXA pixa,
int cellw,
int cellh,
IntPointer pncols,
PointerPointer pboxa) |
static PIX |
lept.pixaDisplayPairTiledInColumns(PIXA pixas1,
PIXA pixas2,
int nx,
float scalefactor,
int spacing1,
int spacing2,
int border1,
int border2,
int fontsize,
int startindex,
SARRAY sa) |
static PIX |
lept.pixaDisplayRandomCmap(PIXA pixa,
int w,
int h) |
static PIX |
lept.pixaDisplayTiled(PIXA pixa,
int maxwidth,
int background,
int spacing) |
static PIX |
lept.pixaDisplayTiledAndScaled(PIXA pixa,
int outdepth,
int tilewidth,
int ncols,
int background,
int spacing,
int border) |
static PIX |
lept.pixaDisplayTiledByIndex(PIXA pixa,
NUMA na,
int width,
int spacing,
int border,
int fontsize,
int textcolor) |
static PIX |
lept.pixaDisplayTiledInColumns(PIXA pixas,
int nx,
float scalefactor,
int spacing,
int border) |
static PIX |
lept.pixaDisplayTiledInRows(PIXA pixa,
int outdepth,
int maxwidth,
float scalefactor,
int background,
int spacing,
int border) |
static PIX |
lept.pixaDisplayTiledWithText(PIXA pixa,
int maxwidth,
float scalefactor,
int spacing,
int border,
int fontsize,
int textcolor) |
static PIX |
lept.pixaDisplayUnsplit(PIXA pixa,
int nx,
int ny,
int borderwidth,
int bordercolor) |
static PIX |
lept.pixAffine(PIX pixs,
float[] vc,
int incolor) |
static PIX |
lept.pixAffine(PIX pixs,
FloatBuffer vc,
int incolor) |
static PIX |
lept.pixAffine(PIX pixs,
FloatPointer vc,
int incolor) |
static PIX |
lept.pixAffineColor(PIX pixs,
float[] vc,
int colorval) |
static PIX |
lept.pixAffineColor(PIX pixs,
FloatBuffer vc,
int colorval) |
static PIX |
lept.pixAffineColor(PIX pixs,
FloatPointer vc,
int colorval) |
static PIX |
lept.pixAffineGray(PIX pixs,
float[] vc,
byte grayval) |
static PIX |
lept.pixAffineGray(PIX pixs,
FloatBuffer vc,
byte grayval) |
static PIX |
lept.pixAffineGray(PIX pixs,
FloatPointer vc,
byte grayval) |
static PIX |
lept.pixAffinePta(PIX pixs,
PTA ptad,
PTA ptas,
int incolor) |
static PIX |
lept.pixAffinePtaColor(PIX pixs,
PTA ptad,
PTA ptas,
int colorval) |
static PIX |
lept.pixAffinePtaGray(PIX pixs,
PTA ptad,
PTA ptas,
byte grayval) |
static PIX |
lept.pixAffinePtaWithAlpha(PIX pixs,
PTA ptad,
PTA ptas,
PIX pixg,
float fract,
int border) |
static PIX |
lept.pixAffineSampled(PIX pixs,
float[] vc,
int incolor) |
static PIX |
lept.pixAffineSampled(PIX pixs,
FloatBuffer vc,
int incolor) |
static PIX |
lept.pixAffineSampled(PIX pixs,
FloatPointer vc,
int incolor) |
static PIX |
lept.pixAffineSampledPta(PIX pixs,
PTA ptad,
PTA ptas,
int incolor) |
static PIX |
lept.pixAffineSequential(PIX pixs,
PTA ptad,
PTA ptas,
int bw,
int bh) |
static PIX |
lept.pixaGetAlignedStats(PIXA pixa,
int type,
int nbins,
int thresh) |
static PIX |
lept.pixaGetPix(PIXA pixa,
int index,
int accesstype) |
static PIX |
lept.pixAlphaBlendUniform(PIX pixs,
int color) |
static PIX |
lept.pixAnd(PIX pixd,
PIX pixs1,
PIX pixs2) |
static PIX |
lept.pixApplyInvBackgroundGrayMap(PIX pixs,
PIX pixm,
int sx,
int sy) |
static PIX |
lept.pixApplyInvBackgroundRGBMap(PIX pixs,
PIX pixmr,
PIX pixmg,
PIX pixmb,
int sx,
int sy) |
static PIX |
lept.pixApplyVariableGrayMap(PIX pixs,
PIX pixg,
int target) |
static PIX |
lept.pixaRenderComponent(PIX pixs,
PIXA pixa,
int index) |
static PIX |
lept.pixAutoPhotoinvert(PIX pixs,
int thresh,
PIX ppixm,
PIXA pixadb) |
static PIX |
lept.pixAutoPhotoinvert(PIX pixs,
int thresh,
PointerPointer ppixm,
PIXA pixadb) |
static PIX |
lept.pixBackgroundNorm(PIX pixs,
PIX pixim,
PIX pixg,
int sx,
int sy,
int thresh,
int mincount,
int bgval,
int smoothx,
int smoothy) |
static PIX |
lept.pixBackgroundNormFlex(PIX pixs,
int sx,
int sy,
int smoothx,
int smoothy,
int delta) |
static PIX |
lept.pixBackgroundNormMorph(PIX pixs,
PIX pixim,
int reduction,
int size,
int bgval) |
static PIX |
lept.pixBackgroundNormSimple(PIX pixs,
PIX pixim,
PIX pixg) |
static PIX |
lept.pixBilateral(PIX pixs,
float spatial_stdev,
float range_stdev,
int ncomps,
int reduction) |
static PIX |
lept.pixBilateralExact(PIX pixs,
L_KERNEL spatial_kel,
L_KERNEL range_kel) |
static PIX |
lept.pixBilateralGray(PIX pixs,
float spatial_stdev,
float range_stdev,
int ncomps,
int reduction) |
static PIX |
lept.pixBilateralGrayExact(PIX pixs,
L_KERNEL spatial_kel,
L_KERNEL range_kel) |
static PIX |
lept.pixBilinear(PIX pixs,
float[] vc,
int incolor) |
static PIX |
lept.pixBilinear(PIX pixs,
FloatBuffer vc,
int incolor) |
static PIX |
lept.pixBilinear(PIX pixs,
FloatPointer vc,
int incolor) |
static PIX |
lept.pixBilinearColor(PIX pixs,
float[] vc,
int colorval) |
static PIX |
lept.pixBilinearColor(PIX pixs,
FloatBuffer vc,
int colorval) |
static PIX |
lept.pixBilinearColor(PIX pixs,
FloatPointer vc,
int colorval) |
static PIX |
lept.pixBilinearGray(PIX pixs,
float[] vc,
byte grayval) |
static PIX |
lept.pixBilinearGray(PIX pixs,
FloatBuffer vc,
byte grayval) |
static PIX |
lept.pixBilinearGray(PIX pixs,
FloatPointer vc,
byte grayval) |
static PIX |
lept.pixBilinearPta(PIX pixs,
PTA ptad,
PTA ptas,
int incolor) |
static PIX |
lept.pixBilinearPtaColor(PIX pixs,
PTA ptad,
PTA ptas,
int colorval) |
static PIX |
lept.pixBilinearPtaGray(PIX pixs,
PTA ptad,
PTA ptas,
byte grayval) |
static PIX |
lept.pixBilinearPtaWithAlpha(PIX pixs,
PTA ptad,
PTA ptas,
PIX pixg,
float fract,
int border) |
static PIX |
lept.pixBilinearSampled(PIX pixs,
float[] vc,
int incolor) |
static PIX |
lept.pixBilinearSampled(PIX pixs,
FloatBuffer vc,
int incolor) |
static PIX |
lept.pixBilinearSampled(PIX pixs,
FloatPointer vc,
int incolor) |
static PIX |
lept.pixBilinearSampledPta(PIX pixs,
PTA ptad,
PTA ptas,
int incolor) |
static PIX |
lept.pixBlend(PIX pixs1,
PIX pixs2,
int x,
int y,
float fract) |
static PIX |
lept.pixBlendBackgroundToColor(PIX pixd,
PIX pixs,
BOX box,
int color,
float gamma,
int minval,
int maxval) |
static PIX |
lept.pixBlendBoxaRandom(PIX pixs,
BOXA boxa,
float fract) |
static PIX |
lept.pixBlendColor(PIX pixd,
PIX pixs1,
PIX pixs2,
int x,
int y,
float fract,
int transparent,
int transpix) |
static PIX |
lept.pixBlendColorByChannel(PIX pixd,
PIX pixs1,
PIX pixs2,
int x,
int y,
float rfract,
float gfract,
float bfract,
int transparent,
int transpix) |
static PIX |
lept.pixBlendGray(PIX pixd,
PIX pixs1,
PIX pixs2,
int x,
int y,
float fract,
int type,
int transparent,
int transpix) |
static PIX |
lept.pixBlendGrayAdapt(PIX pixd,
PIX pixs1,
PIX pixs2,
int x,
int y,
float fract,
int shift) |
static PIX |
lept.pixBlendGrayInverse(PIX pixd,
PIX pixs1,
PIX pixs2,
int x,
int y,
float fract) |
static PIX |
lept.pixBlendHardLight(PIX pixd,
PIX pixs1,
PIX pixs2,
int x,
int y,
float fract) |
static PIX |
lept.pixBlendMask(PIX pixd,
PIX pixs1,
PIX pixs2,
int x,
int y,
float fract,
int type) |
static PIX |
lept.pixBlendWithGrayMask(PIX pixs1,
PIX pixs2,
PIX pixg,
int x,
int y) |
static PIX |
lept.pixBlockBilateralExact(PIX pixs,
float spatial_stdev,
float range_stdev) |
static PIX |
lept.pixBlockconv(PIX pix,
int wc,
int hc) |
static PIX |
lept.pixBlockconvAccum(PIX pixs) |
static PIX |
lept.pixBlockconvGray(PIX pixs,
PIX pixacc,
int wc,
int hc) |
static PIX |
lept.pixBlockconvGrayTile(PIX pixs,
PIX pixacc,
int wc,
int hc) |
static PIX |
lept.pixBlockconvGrayUnnormalized(PIX pixs,
int wc,
int hc) |
static PIX |
lept.pixBlockconvTiled(PIX pix,
int wc,
int hc,
int nx,
int ny) |
static PIX |
lept.pixBlockrank(PIX pixs,
PIX pixacc,
int wc,
int hc,
float rank) |
static PIX |
lept.pixBlocksum(PIX pixs,
PIX pixacc,
int wc,
int hc) |
static PIX |
lept.pixCensusTransform(PIX pixs,
int halfsize,
PIX pixacc) |
static PIX |
lept.pixCleanBackgroundToWhite(PIX pixs,
PIX pixim,
PIX pixg,
float gamma,
int blackval,
int whiteval) |
static PIX |
lept.pixClipMasked(PIX pixs,
PIX pixm,
int x,
int y,
int outval) |
static PIX |
lept.pixClipRectangle(PIX pixs,
BOX box,
BOX pboxc) |
static PIX |
lept.pixClipRectangle(PIX pixs,
BOX box,
PointerPointer pboxc) |
static PIX |
lept.pixClipRectangleWithBorder(PIX pixs,
BOX box,
int maxbord,
BOX pboxn) |
static PIX |
lept.pixClipRectangleWithBorder(PIX pixs,
BOX box,
int maxbord,
PointerPointer pboxn) |
static PIX |
lept.pixClone(PIX pixs) |
static PIX |
lept.pixClose(PIX pixd,
PIX pixs,
SEL sel) |
static PIX |
lept.pixCloseBrick(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixCloseBrickDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixCloseCompBrick(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixCloseCompBrickDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixCloseCompBrickExtendDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixCloseGeneralized(PIX pixd,
PIX pixs,
SEL sel) |
static PIX |
lept.pixCloseGray(PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixCloseGray3(PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixCloseSafe(PIX pixd,
PIX pixs,
SEL sel) |
static PIX |
lept.pixCloseSafeBrick(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixCloseSafeCompBrick(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixColorFill(PIX pixs,
int minmax,
int maxdiff,
int smooth,
int minarea,
int debug) |
static PIX |
lept.pixColorGrayMasked(PIX pixs,
PIX pixm,
int type,
int thresh,
int rval,
int gval,
int bval) |
static PIX |
lept.pixColorGrayRegions(PIX pixs,
BOXA boxa,
int type,
int thresh,
int rval,
int gval,
int bval) |
static PIX |
lept.pixColorizeGray(PIX pixs,
int color,
int cmapflag) |
static PIX |
lept.pixColorMagnitude(PIX pixs,
int rref,
int gref,
int bref,
int type) |
static PIX |
lept.pixColorMorph(PIX pixs,
int type,
int hsize,
int vsize) |
static PIX |
lept.pixColorMorphSequence(PIX pixs,
BytePointer sequence,
int dispsep,
int dispy) |
static PIX |
lept.pixColorMorphSequence(PIX pixs,
String sequence,
int dispsep,
int dispy) |
static PIX |
lept.pixColorSegment(PIX pixs,
int maxdist,
int maxcolors,
int selsize,
int finalcolors,
int debugflag) |
static PIX |
lept.pixColorSegmentCluster(PIX pixs,
int maxdist,
int maxcolors,
int debugflag) |
static PIX |
lept.pixColorShiftRGB(PIX pixs,
float rfract,
float gfract,
float bfract) |
static PIX |
lept.pixColorShiftWhitePoint(PIX pixs,
int rref,
int gref,
int bref) |
static PIX |
lept.pixConnCompAreaTransform(PIX pixs,
int connect) |
static PIX |
lept.pixConnCompTransform(PIX pixs,
int connect,
int depth) |
static PIX |
lept.pixContrastNorm(PIX pixd,
PIX pixs,
int sx,
int sy,
int mindiff,
int smoothx,
int smoothy) |
static PIX |
lept.pixContrastTRC(PIX pixd,
PIX pixs,
float factor) |
static PIX |
lept.pixContrastTRCMasked(PIX pixd,
PIX pixs,
PIX pixm,
float factor) |
static PIX |
lept.pixConvert16To8(PIX pixs,
int type) |
static PIX |
lept.pixConvert1To16(PIX pixd,
PIX pixs,
short val0,
short val1) |
static PIX |
lept.pixConvert1To2(PIX pixd,
PIX pixs,
int val0,
int val1) |
static PIX |
lept.pixConvert1To2Cmap(PIX pixs) |
static PIX |
lept.pixConvert1To32(PIX pixd,
PIX pixs,
int val0,
int val1) |
static PIX |
lept.pixConvert1To4(PIX pixd,
PIX pixs,
int val0,
int val1) |
static PIX |
lept.pixConvert1To4Cmap(PIX pixs) |
static PIX |
lept.pixConvert1To8(PIX pixd,
PIX pixs,
byte val0,
byte val1) |
static PIX |
lept.pixConvert1To8Cmap(PIX pixs) |
static PIX |
lept.pixConvert24To32(PIX pixs) |
static PIX |
lept.pixConvert2To8(PIX pixs,
byte val0,
byte val1,
byte val2,
byte val3,
int cmapflag) |
static PIX |
lept.pixConvert32To16(PIX pixs,
int type) |
static PIX |
lept.pixConvert32To24(PIX pixs) |
static PIX |
lept.pixConvert32To8(PIX pixs,
int type16,
int type8) |
static PIX |
lept.pixConvert4To8(PIX pixs,
int cmapflag) |
static PIX |
lept.pixConvert8To16(PIX pixs,
int leftshift) |
static PIX |
lept.pixConvert8To2(PIX pix) |
static PIX |
lept.pixConvert8To32(PIX pixs) |
static PIX |
lept.pixConvert8To4(PIX pix) |
static PIX |
lept.pixConvertCmapTo1(PIX pixs) |
static PIX |
lept.pixConvertColorToSubpixelRGB(PIX pixs,
float scalex,
float scaley,
int order) |
static PIX |
lept.pixConvertForPSWrap(PIX pixs) |
static PIX |
lept.pixConvertGrayToColormap(PIX pixs) |
static PIX |
lept.pixConvertGrayToColormap8(PIX pixs,
int mindepth) |
static PIX |
lept.pixConvertGrayToFalseColor(PIX pixs,
float gamma) |
static PIX |
lept.pixConvertGrayToSubpixelRGB(PIX pixs,
float scalex,
float scaley,
int order) |
static PIX |
lept.pixConvertHSVToRGB(PIX pixd,
PIX pixs) |
static PIX |
lept.pixConvertLossless(PIX pixs,
int d) |
static PIX |
lept.pixConvertRGBToBinaryArb(PIX pixs,
float rc,
float gc,
float bc,
int thresh,
int relation) |
static PIX |
lept.pixConvertRGBToCmapLossless(PIX pixs) |
static PIX |
lept.pixConvertRGBToColormap(PIX pixs,
int ditherflag) |
static PIX |
lept.pixConvertRGBToGray(PIX pixs,
float rwt,
float gwt,
float bwt) |
static PIX |
lept.pixConvertRGBToGrayArb(PIX pixs,
float rc,
float gc,
float bc) |
static PIX |
lept.pixConvertRGBToGrayFast(PIX pixs) |
static PIX |
lept.pixConvertRGBToGrayGeneral(PIX pixs,
int type,
float rwt,
float gwt,
float bwt) |
static PIX |
lept.pixConvertRGBToGrayMinMax(PIX pixs,
int type) |
static PIX |
lept.pixConvertRGBToGraySatBoost(PIX pixs,
int refval) |
static PIX |
lept.pixConvertRGBToHSV(PIX pixd,
PIX pixs) |
static PIX |
lept.pixConvertRGBToHue(PIX pixs) |
static PIX |
lept.pixConvertRGBToLuminance(PIX pixs) |
static PIX |
lept.pixConvertRGBToSaturation(PIX pixs) |
static PIX |
lept.pixConvertRGBToValue(PIX pixs) |
static PIX |
lept.pixConvertRGBToYUV(PIX pixd,
PIX pixs) |
static PIX |
lept.pixConvertTo1(PIX pixs,
int threshold) |
static PIX |
lept.pixConvertTo16(PIX pixs) |
static PIX |
lept.pixConvertTo1Adaptive(PIX pixs) |
static PIX |
lept.pixConvertTo1BySampling(PIX pixs,
int factor,
int threshold) |
static PIX |
lept.pixConvertTo2(PIX pixs) |
static PIX |
lept.pixConvertTo32(PIX pixs) |
static PIX |
lept.pixConvertTo32BySampling(PIX pixs,
int factor) |
static PIX |
lept.pixConvertTo4(PIX pixs) |
static PIX |
lept.pixConvertTo8(PIX pixs,
int cmapflag) |
static PIX |
lept.pixConvertTo8BySampling(PIX pixs,
int factor,
int cmapflag) |
static PIX |
lept.pixConvertTo8Colormap(PIX pixs,
int dither) |
static PIX |
lept.pixConvertTo8Or32(PIX pixs,
int copyflag,
int warnflag) |
static PIX |
lept.pixConvertToSubpixelRGB(PIX pixs,
float scalex,
float scaley,
int order) |
static PIX |
lept.pixConvertYUVToRGB(PIX pixd,
PIX pixs) |
static PIX |
lept.pixConvolve(PIX pixs,
L_KERNEL kel,
int outdepth,
int normflag) |
static PIX |
lept.pixConvolveRGB(PIX pixs,
L_KERNEL kel) |
static PIX |
lept.pixConvolveRGBSep(PIX pixs,
L_KERNEL kelx,
L_KERNEL kely) |
static PIX |
lept.pixConvolveSep(PIX pixs,
L_KERNEL kelx,
L_KERNEL kely,
int outdepth,
int normflag) |
static PIX |
lept.pixConvolveWithBias(PIX pixs,
L_KERNEL kel1,
L_KERNEL kel2,
int force8,
int[] pbias) |
static PIX |
lept.pixConvolveWithBias(PIX pixs,
L_KERNEL kel1,
L_KERNEL kel2,
int force8,
IntBuffer pbias) |
static PIX |
lept.pixConvolveWithBias(PIX pixs,
L_KERNEL kel1,
L_KERNEL kel2,
int force8,
IntPointer pbias) |
static PIX |
lept.pixCopy(PIX pixd,
PIX pixs) |
static PIX |
lept.pixCopyBorder(PIX pixd,
PIX pixs,
int left,
int right,
int top,
int bot) |
static PIX |
lept.pixCopyWithBoxa(PIX pixs,
BOXA boxa,
int background) |
static PIX |
lept.pixCreate(int width,
int height,
int depth) |
static PIX |
lept.pixCreateFromPixcomp(PIXC pixc) |
static PIX |
lept.pixCreateHeader(int width,
int height,
int depth) |
static PIX |
lept.pixCreateNoInit(int width,
int height,
int depth) |
static PIX |
lept.pixCreateRGBImage(PIX pixr,
PIX pixg,
PIX pixb) |
static PIX |
lept.pixCreateTemplate(PIX pixs) |
static PIX |
lept.pixCreateTemplateNoInit(PIX pixs) |
static PIX |
lept.pixCreateWithCmap(int width,
int height,
int depth,
int initcolor) |
static PIX |
lept.pixCropToSize(PIX pixs,
int w,
int h) |
static PIX |
lept.pixDarkenGray(PIX pixd,
PIX pixs,
int thresh,
int satlimit) |
static PIX |
lept.pixDeserializeFromMemory(int[] data,
long nbytes) |
static PIX |
lept.pixDeserializeFromMemory(IntBuffer data,
long nbytes) |
static PIX |
lept.pixDeserializeFromMemory(IntPointer data,
long nbytes) |
static PIX |
lept.pixDeskew(PIX pixs,
int redsearch) |
static PIX |
lept.pixDeskewBarcode(PIX pixs,
PIX pixb,
BOX box,
int margin,
int threshold,
float[] pangle,
float[] pconf) |
static PIX |
lept.pixDeskewBarcode(PIX pixs,
PIX pixb,
BOX box,
int margin,
int threshold,
FloatBuffer pangle,
FloatBuffer pconf) |
static PIX |
lept.pixDeskewBarcode(PIX pixs,
PIX pixb,
BOX box,
int margin,
int threshold,
FloatPointer pangle,
FloatPointer pconf) |
static PIX |
lept.pixDeskewBoth(PIX pixs,
int redsearch) |
static PIX |
lept.pixDeskewGeneral(PIX pixs,
int redsweep,
float sweeprange,
float sweepdelta,
int redsearch,
int thresh,
float[] pangle,
float[] pconf) |
static PIX |
lept.pixDeskewGeneral(PIX pixs,
int redsweep,
float sweeprange,
float sweepdelta,
int redsearch,
int thresh,
FloatBuffer pangle,
FloatBuffer pconf) |
static PIX |
lept.pixDeskewGeneral(PIX pixs,
int redsweep,
float sweeprange,
float sweepdelta,
int redsearch,
int thresh,
FloatPointer pangle,
FloatPointer pconf) |
static PIX |
lept.pixDeskewLocal(PIX pixs,
int nslices,
int redsweep,
int redsearch,
float sweeprange,
float sweepdelta,
float minbsdelta) |
static PIX |
lept.pixDilate(PIX pixd,
PIX pixs,
SEL sel) |
static PIX |
lept.pixDilateBrick(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixDilateBrickDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixDilateCompBrick(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixDilateCompBrickDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixDilateCompBrickExtendDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixDilateGray(PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixDilateGray3(PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixDisplayColorArray(int[] carray,
int ncolors,
int side,
int ncols,
int fontsize) |
static PIX |
lept.pixDisplayColorArray(IntBuffer carray,
int ncolors,
int side,
int ncols,
int fontsize) |
static PIX |
lept.pixDisplayColorArray(IntPointer carray,
int ncolors,
int side,
int ncols,
int fontsize) |
static PIX |
lept.pixDisplayDiffBinary(PIX pix1,
PIX pix2) |
static PIX |
lept.pixDisplayHitMissSel(PIX pixs,
SEL sel,
int scalefactor,
int hitcolor,
int misscolor) |
static PIX |
lept.pixDisplayLayersRGBA(PIX pixs,
int val,
int maxw) |
static PIX |
lept.pixDisplayMatchedPattern(PIX pixs,
PIX pixp,
PIX pixe,
int x0,
int y0,
int color,
float scale,
int nlevels) |
static PIX |
lept.pixDisplayPta(PIX pixd,
PIX pixs,
PTA pta) |
static PIX |
lept.pixDisplayPtaa(PIX pixs,
PTAA ptaa) |
static PIX |
lept.pixDisplayPtaaPattern(PIX pixd,
PIX pixs,
PTAA ptaa,
PIX pixp,
int cx,
int cy) |
static PIX |
lept.pixDisplayPtaPattern(PIX pixd,
PIX pixs,
PTA pta,
PIX pixp,
int cx,
int cy,
int color) |
static PIX |
lept.pixDisplaySelectedPixels(PIX pixs,
PIX pixm,
SEL sel,
int val) |
static PIX |
lept.pixDistanceFunction(PIX pixs,
int connectivity,
int outdepth,
int boundcond) |
static PIX |
lept.pixDitherTo2bpp(PIX pixs,
int cmapflag) |
static PIX |
lept.pixDitherTo2bppSpec(PIX pixs,
int lowerclip,
int upperclip,
int cmapflag) |
static PIX |
lept.pixDitherToBinary(PIX pixs) |
static PIX |
lept.pixDitherToBinarySpec(PIX pixs,
int lowerclip,
int upperclip) |
static PIX |
lept.pixDrawBoxa(PIX pixs,
BOXA boxa,
int width,
int val) |
static PIX |
lept.pixDrawBoxaRandom(PIX pixs,
BOXA boxa,
int width) |
static PIX |
lept.pixEmbedForRotation(PIX pixs,
float angle,
int incolor,
int width,
int height) |
static PIX |
lept.pixEndianByteSwapNew(PIX pixs) |
static PIX |
lept.pixEndianTwoByteSwapNew(PIX pixs) |
static PIX |
lept.pixEqualizeTRC(PIX pixd,
PIX pixs,
float fract,
int factor) |
static PIX |
lept.pixErode(PIX pixd,
PIX pixs,
SEL sel) |
static PIX |
lept.pixErodeBrick(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixErodeBrickDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixErodeCompBrick(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixErodeCompBrickDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixErodeCompBrickExtendDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixErodeGray(PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixErodeGray3(PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixExpandBinaryPower2(PIX pixs,
int factor) |
static PIX |
lept.pixExpandBinaryReplicate(PIX pixs,
int xfact,
int yfact) |
static PIX |
lept.pixExpandReplicate(PIX pixs,
int factor) |
static PIX |
lept.pixExtendByReplication(PIX pixs,
int addw,
int addh) |
static PIX |
lept.pixExtractBorderConnComps(PIX pixs,
int connectivity) |
static PIX |
lept.pixExtractBoundary(PIX pixs,
int type) |
static PIX |
lept.pixFadeWithGray(PIX pixs,
PIX pixb,
float factor,
int type) |
static PIX |
lept.pixFastTophat(PIX pixs,
int xsize,
int ysize,
int type) |
static PIX |
lept.pixFewColorsMedianCutQuantMixed(PIX pixs,
int ncolor,
int ngray,
int maxncolors,
int darkthresh,
int lightthresh,
int diffthresh) |
static PIX |
lept.pixFewColorsOctcubeQuant1(PIX pixs,
int level) |
static PIX |
lept.pixFewColorsOctcubeQuant2(PIX pixs,
int level,
NUMA na,
int ncolors,
int[] pnerrors) |
static PIX |
lept.pixFewColorsOctcubeQuant2(PIX pixs,
int level,
NUMA na,
int ncolors,
IntBuffer pnerrors) |
static PIX |
lept.pixFewColorsOctcubeQuant2(PIX pixs,
int level,
NUMA na,
int ncolors,
IntPointer pnerrors) |
static PIX |
lept.pixFewColorsOctcubeQuantMixed(PIX pixs,
int level,
int darkthresh,
int lightthresh,
int diffthresh,
float minfract,
int maxspan) |
static PIX |
lept.pixFHMTGen_1(PIX pixd,
PIX pixs,
BytePointer selname) |
static PIX |
lept.pixFHMTGen_1(PIX pixd,
PIX pixs,
String selname) |
static PIX |
lept.pixFillBgFromBorder(PIX pixs,
int connectivity) |
static PIX |
lept.pixFillClosedBorders(PIX pixs,
int connectivity) |
static PIX |
lept.pixFillHolesToBoundingRect(PIX pixs,
int minsize,
float maxhfract,
float minfgfract) |
static PIX |
lept.pixFillPolygon(PIX pixs,
PTA pta,
int xmin,
int ymin) |
static PIX |
lept.pixFilterComponentBySize(PIX pixs,
int rankorder,
int type,
int connectivity,
BOX pbox) |
static PIX |
lept.pixFilterComponentBySize(PIX pixs,
int rankorder,
int type,
int connectivity,
PointerPointer pbox) |
static PIX |
lept.pixFinalAccumulate(PIX pixs,
int offset,
int depth) |
static PIX |
lept.pixFinalAccumulateThreshold(PIX pixs,
int offset,
int threshold) |
static PIX |
lept.pixFindEqualValues(PIX pixs1,
PIX pixs2) |
static PIX |
lept.pixFindSkewAndDeskew(PIX pixs,
int redsearch,
float[] pangle,
float[] pconf) |
static PIX |
lept.pixFindSkewAndDeskew(PIX pixs,
int redsearch,
FloatBuffer pangle,
FloatBuffer pconf) |
static PIX |
lept.pixFindSkewAndDeskew(PIX pixs,
int redsearch,
FloatPointer pangle,
FloatPointer pconf) |
static PIX |
lept.pixFixedOctcubeQuant256(PIX pixs,
int ditherflag) |
static PIX |
lept.pixFixedOctcubeQuantGenRGB(PIX pixs,
int level) |
static PIX |
lept.pixFlipLR(PIX pixd,
PIX pixs) |
static PIX |
lept.pixFlipTB(PIX pixd,
PIX pixs) |
static PIX |
lept.pixFMorphopGen_1(PIX pixd,
PIX pixs,
int operation,
byte[] selname) |
static PIX |
lept.pixFMorphopGen_1(PIX pixd,
PIX pixs,
int operation,
ByteBuffer selname) |
static PIX |
lept.pixFMorphopGen_1(PIX pixd,
PIX pixs,
int operation,
BytePointer selname) |
static PIX |
lept.pixFMorphopGen_2(PIX pixd,
PIX pixs,
int operation,
byte[] selname) |
static PIX |
lept.pixFMorphopGen_2(PIX pixd,
PIX pixs,
int operation,
ByteBuffer selname) |
static PIX |
lept.pixFMorphopGen_2(PIX pixd,
PIX pixs,
int operation,
BytePointer selname) |
static PIX |
lept.pixGammaTRC(PIX pixd,
PIX pixs,
float gamma,
int minval,
int maxval) |
static PIX |
lept.pixGammaTRCMasked(PIX pixd,
PIX pixs,
PIX pixm,
float gamma,
int minval,
int maxval) |
static PIX |
lept.pixGammaTRCWithAlpha(PIX pixd,
PIX pixs,
float gamma,
int minval,
int maxval) |
static PIX |
lept.pixGenerateFromPta(PTA pta,
int w,
int h) |
static PIX |
lept.pixGenerateHalftoneMask(PIX pixs,
PIX ppixtext,
int[] phtfound,
PIXA pixadb) |
static PIX |
lept.pixGenerateHalftoneMask(PIX pixs,
PIX ppixtext,
IntBuffer phtfound,
PIXA pixadb) |
static PIX |
lept.pixGenerateHalftoneMask(PIX pixs,
PIX ppixtext,
IntPointer phtfound,
PIXA pixadb) |
static PIX |
lept.pixGenerateHalftoneMask(PIX pixs,
PointerPointer ppixtext,
IntPointer phtfound,
PIXA pixadb) |
static PIX |
lept.pixGenerateMaskByBand(PIX pixs,
int lower,
int upper,
int inband,
int usecmap) |
static PIX |
lept.pixGenerateMaskByBand32(PIX pixs,
int refval,
int delm,
int delp,
float fractm,
float fractp) |
static PIX |
lept.pixGenerateMaskByDiscr32(PIX pixs,
int refval1,
int refval2,
int distflag) |
static PIX |
lept.pixGenerateMaskByValue(PIX pixs,
int val,
int usecmap) |
static PIX |
lept.pixGenHalftoneMask(PIX pixs,
PIX ppixtext,
int[] phtfound,
int debug) |
static PIX |
lept.pixGenHalftoneMask(PIX pixs,
PIX ppixtext,
IntBuffer phtfound,
int debug) |
static PIX |
lept.pixGenHalftoneMask(PIX pixs,
PIX ppixtext,
IntPointer phtfound,
int debug) |
static PIX |
lept.pixGenHalftoneMask(PIX pixs,
PointerPointer ppixtext,
IntPointer phtfound,
int debug) |
static PIX |
lept.pixGenTextblockMask(PIX pixs,
PIX pixvws,
PIXA pixadb) |
static PIX |
lept.pixGenTextlineMask(PIX pixs,
PIX ppixvws,
int[] ptlfound,
PIXA pixadb) |
static PIX |
lept.pixGenTextlineMask(PIX pixs,
PIX ppixvws,
IntBuffer ptlfound,
PIXA pixadb) |
static PIX |
lept.pixGenTextlineMask(PIX pixs,
PIX ppixvws,
IntPointer ptlfound,
PIXA pixadb) |
static PIX |
lept.pixGenTextlineMask(PIX pixs,
PointerPointer ppixvws,
IntPointer ptlfound,
PIXA pixadb) |
static PIX |
lept.pixGetAverageTiled(PIX pixs,
int sx,
int sy,
int type) |
static PIX |
lept.pixGetInvBackgroundMap(PIX pixs,
int bgval,
int smoothx,
int smoothy) |
static PIX |
lept.pixGetRGBComponent(PIX pixs,
int comp) |
static PIX |
lept.pixGetRGBComponentCmap(PIX pixs,
int comp) |
static PIX |
lept.pixGlobalNormNoSatRGB(PIX pixd,
PIX pixs,
int rval,
int gval,
int bval,
int factor,
float rank) |
static PIX |
lept.pixGlobalNormRGB(PIX pixd,
PIX pixs,
int rval,
int gval,
int bval,
int mapval) |
static PIX |
lept.pixGrayMorphSequence(PIX pixs,
BytePointer sequence,
int dispsep,
int dispy) |
static PIX |
lept.pixGrayMorphSequence(PIX pixs,
String sequence,
int dispsep,
int dispy) |
static PIX |
lept.pixGrayQuantFromCmap(PIX pixs,
PIXCMAP cmap,
int mindepth) |
static PIX |
lept.pixGrayQuantFromHisto(PIX pixd,
PIX pixs,
PIX pixm,
float minfract,
int maxsize) |
static PIX |
lept.pixHalfEdgeByBandpass(PIX pixs,
int sm1h,
int sm1v,
int sm2h,
int sm2v) |
static PIX |
lept.pixHDome(PIX pixs,
int height,
int connectivity) |
static PIX |
lept.pixHMT(PIX pixd,
PIX pixs,
SEL sel) |
static PIX |
lept.pixHMTDwa_1(PIX pixd,
PIX pixs,
BytePointer selname) |
static PIX |
lept.pixHMTDwa_1(PIX pixd,
PIX pixs,
String selname) |
static PIX |
lept.pixHolesByFilling(PIX pixs,
int connectivity) |
static PIX |
lept.pixHShear(PIX pixd,
PIX pixs,
int yloc,
float radang,
int incolor) |
static PIX |
lept.pixHShearCenter(PIX pixd,
PIX pixs,
float radang,
int incolor) |
static PIX |
lept.pixHShearCorner(PIX pixd,
PIX pixs,
float radang,
int incolor) |
static PIX |
lept.pixHShearLI(PIX pixs,
int yloc,
float radang,
int incolor) |
static PIX |
lept.pixInitAccumulate(int w,
int h,
int offset) |
static PIX |
lept.pixIntersectionOfMorphOps(PIX pixs,
SELA sela,
int type) |
static PIX |
lept.pixInvert(PIX pixd,
PIX pixs) |
static PIX |
lept.pixLinearMapToTargetColor(PIX pixd,
PIX pixs,
int srcval,
int dstval) |
static PIX |
lept.pixLocToColorTransform(PIX pixs) |
static PIX |
lept.pixMakeAlphaFromMask(PIX pixs,
int dist,
BOX pbox) |
static PIX |
lept.pixMakeAlphaFromMask(PIX pixs,
int dist,
PointerPointer pbox) |
static PIX |
lept.pixMakeArbMaskFromRGB(PIX pixs,
float rc,
float gc,
float bc,
float thresh) |
static PIX |
lept.pixMakeColorSquare(int color,
int size,
int addlabel,
int location,
int textcolor) |
static PIX |
lept.pixMakeCoveringOfRectangles(PIX pixs,
int maxiters) |
static PIX |
lept.pixMakeFrameMask(int w,
int h,
float hf1,
float hf2,
float vf1,
float vf2) |
static PIX |
lept.pixMakeGamutRGB(int scale) |
static PIX |
lept.pixMakeHistoHS(PIX pixs,
int factor,
NUMA pnahue,
NUMA pnasat) |
static PIX |
lept.pixMakeHistoHS(PIX pixs,
int factor,
PointerPointer pnahue,
PointerPointer pnasat) |
static PIX |
lept.pixMakeHistoHV(PIX pixs,
int factor,
NUMA pnahue,
NUMA pnaval) |
static PIX |
lept.pixMakeHistoHV(PIX pixs,
int factor,
PointerPointer pnahue,
PointerPointer pnaval) |
static PIX |
lept.pixMakeHistoSV(PIX pixs,
int factor,
NUMA pnasat,
NUMA pnaval) |
static PIX |
lept.pixMakeHistoSV(PIX pixs,
int factor,
PointerPointer pnasat,
PointerPointer pnaval) |
static PIX |
lept.pixMakeMaskFromLUT(PIX pixs,
int[] tab) |
static PIX |
lept.pixMakeMaskFromLUT(PIX pixs,
IntBuffer tab) |
static PIX |
lept.pixMakeMaskFromLUT(PIX pixs,
IntPointer tab) |
static PIX |
lept.pixMakeMaskFromVal(PIX pixs,
int val) |
static PIX |
lept.pixMakeRangeMaskHS(PIX pixs,
int huecenter,
int huehw,
int satcenter,
int sathw,
int regionflag) |
static PIX |
lept.pixMakeRangeMaskHV(PIX pixs,
int huecenter,
int huehw,
int valcenter,
int valhw,
int regionflag) |
static PIX |
lept.pixMakeRangeMaskSV(PIX pixs,
int satcenter,
int sathw,
int valcenter,
int valhw,
int regionflag) |
static PIX |
lept.pixMakeSymmetricMask(int w,
int h,
float hf,
float vf,
int type) |
static PIX |
lept.pixMapWithInvariantHue(PIX pixd,
PIX pixs,
int srcval,
float fract) |
static PIX |
lept.pixMaskBoxa(PIX pixd,
PIX pixs,
BOXA boxa,
int op) |
static PIX |
lept.pixMaskConnComp(PIX pixs,
int connectivity,
BOXA pboxa) |
static PIX |
lept.pixMaskConnComp(PIX pixs,
int connectivity,
PointerPointer pboxa) |
static PIX |
lept.pixMaskedThreshOnBackgroundNorm(PIX pixs,
PIX pixim,
int sx,
int sy,
int thresh,
int mincount,
int smoothx,
int smoothy,
float scorefract,
int[] pthresh) |
static PIX |
lept.pixMaskedThreshOnBackgroundNorm(PIX pixs,
PIX pixim,
int sx,
int sy,
int thresh,
int mincount,
int smoothx,
int smoothy,
float scorefract,
IntBuffer pthresh) |
static PIX |
lept.pixMaskedThreshOnBackgroundNorm(PIX pixs,
PIX pixim,
int sx,
int sy,
int thresh,
int mincount,
int smoothx,
int smoothy,
float scorefract,
IntPointer pthresh) |
static PIX |
lept.pixMaskOverColorPixels(PIX pixs,
int threshdiff,
int mindist) |
static PIX |
lept.pixMaskOverColorRange(PIX pixs,
int rmin,
int rmax,
int gmin,
int gmax,
int bmin,
int bmax) |
static PIX |
lept.pixMaskOverGrayPixels(PIX pixs,
int maxlimit,
int satlimit) |
static PIX |
lept.pixMaxDynamicRange(PIX pixs,
int type) |
static PIX |
lept.pixMaxDynamicRangeRGB(PIX pixs,
int type) |
static PIX |
lept.pixMedianCutQuant(PIX pixs,
int ditherflag) |
static PIX |
lept.pixMedianCutQuantGeneral(PIX pixs,
int ditherflag,
int outdepth,
int maxcolors,
int sigbits,
int maxsub,
int checkbw) |
static PIX |
lept.pixMedianCutQuantMixed(PIX pixs,
int ncolor,
int ngray,
int darkthresh,
int lightthresh,
int diffthresh) |
static PIX |
lept.pixMedianFilter(PIX pixs,
int wf,
int hf) |
static PIX |
lept.pixMinOrMax(PIX pixd,
PIX pixs1,
PIX pixs2,
int type) |
static PIX |
lept.pixMirroredTiling(PIX pixs,
int w,
int h) |
static PIX |
lept.pixModifyBrightness(PIX pixd,
PIX pixs,
float fract) |
static PIX |
lept.pixModifyHue(PIX pixd,
PIX pixs,
float fract) |
static PIX |
lept.pixModifySaturation(PIX pixd,
PIX pixs,
float fract) |
static PIX |
lept.pixModifyStrokeWidth(PIX pixs,
float width,
float targetw) |
static PIX |
lept.pixMorphCompSequence(PIX pixs,
BytePointer sequence,
int dispsep) |
static PIX |
lept.pixMorphCompSequence(PIX pixs,
String sequence,
int dispsep) |
static PIX |
lept.pixMorphCompSequenceDwa(PIX pixs,
BytePointer sequence,
int dispsep) |
static PIX |
lept.pixMorphCompSequenceDwa(PIX pixs,
String sequence,
int dispsep) |
static PIX |
lept.pixMorphDwa_1(PIX pixd,
PIX pixs,
int operation,
byte[] selname) |
static PIX |
lept.pixMorphDwa_1(PIX pixd,
PIX pixs,
int operation,
ByteBuffer selname) |
static PIX |
lept.pixMorphDwa_1(PIX pixd,
PIX pixs,
int operation,
BytePointer selname) |
static PIX |
lept.pixMorphDwa_2(PIX pixd,
PIX pixs,
int operation,
byte[] selname) |
static PIX |
lept.pixMorphDwa_2(PIX pixd,
PIX pixs,
int operation,
ByteBuffer selname) |
static PIX |
lept.pixMorphDwa_2(PIX pixd,
PIX pixs,
int operation,
BytePointer selname) |
static PIX |
lept.pixMorphGradient(PIX pixs,
int hsize,
int vsize,
int smoothing) |
static PIX |
lept.pixMorphSequence(PIX pixs,
BytePointer sequence,
int dispsep) |
static PIX |
lept.pixMorphSequence(PIX pixs,
String sequence,
int dispsep) |
static PIX |
lept.pixMorphSequenceByComponent(PIX pixs,
BytePointer sequence,
int connectivity,
int minw,
int minh,
BOXA pboxa) |
static PIX |
lept.pixMorphSequenceByComponent(PIX pixs,
BytePointer sequence,
int connectivity,
int minw,
int minh,
PointerPointer pboxa) |
static PIX |
lept.pixMorphSequenceByComponent(PIX pixs,
String sequence,
int connectivity,
int minw,
int minh,
BOXA pboxa) |
static PIX |
lept.pixMorphSequenceByRegion(PIX pixs,
PIX pixm,
BytePointer sequence,
int connectivity,
int minw,
int minh,
BOXA pboxa) |
static PIX |
lept.pixMorphSequenceByRegion(PIX pixs,
PIX pixm,
BytePointer sequence,
int connectivity,
int minw,
int minh,
PointerPointer pboxa) |
static PIX |
lept.pixMorphSequenceByRegion(PIX pixs,
PIX pixm,
String sequence,
int connectivity,
int minw,
int minh,
BOXA pboxa) |
static PIX |
lept.pixMorphSequenceDwa(PIX pixs,
BytePointer sequence,
int dispsep) |
static PIX |
lept.pixMorphSequenceDwa(PIX pixs,
String sequence,
int dispsep) |
static PIX |
lept.pixMorphSequenceMasked(PIX pixs,
PIX pixm,
BytePointer sequence,
int dispsep) |
static PIX |
lept.pixMorphSequenceMasked(PIX pixs,
PIX pixm,
String sequence,
int dispsep) |
static PIX |
lept.pixMosaicColorShiftRGB(PIX pixs,
float roff,
float goff,
float boff,
float delta,
int nincr) |
static PIX |
lept.pixMultConstantColor(PIX pixs,
float rfact,
float gfact,
float bfact) |
static PIX |
lept.pixMultiplyByColor(PIX pixd,
PIX pixs,
BOX box,
int color) |
static PIX |
lept.pixMultiplyGray(PIX pixs,
PIX pixg,
float norm) |
static PIX |
lept.pixMultMatrixColor(PIX pixs,
L_KERNEL kel) |
static PIX |
lept.pixOctcubeQuantFromCmap(PIX pixs,
PIXCMAP cmap,
int mindepth,
int level,
int metric) |
static PIX |
lept.pixOctcubeQuantMixedWithGray(PIX pixs,
int depth,
int graylevels,
int delta) |
static PIX |
lept.pixOctreeColorQuant(PIX pixs,
int colors,
int ditherflag) |
static PIX |
lept.pixOctreeColorQuantGeneral(PIX pixs,
int colors,
int ditherflag,
float validthresh,
float colorthresh) |
static PIX |
lept.pixOctreeQuantByPopulation(PIX pixs,
int level,
int ditherflag) |
static PIX |
lept.pixOctreeQuantNumColors(PIX pixs,
int maxcolors,
int subsample) |
static PIX |
lept.pixOpen(PIX pixd,
PIX pixs,
SEL sel) |
static PIX |
lept.pixOpenBrick(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixOpenBrickDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixOpenCompBrick(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixOpenCompBrickDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixOpenCompBrickExtendDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixOpenGeneralized(PIX pixd,
PIX pixs,
SEL sel) |
static PIX |
lept.pixOpenGray(PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixOpenGray3(PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixOr(PIX pixd,
PIX pixs1,
PIX pixs2) |
static PIX |
lept.pixOrientCorrect(PIX pixs,
float minupconf,
float minratio,
float[] pupconf,
float[] pleftconf,
int[] protation,
int debug) |
static PIX |
lept.pixOrientCorrect(PIX pixs,
float minupconf,
float minratio,
FloatBuffer pupconf,
FloatBuffer pleftconf,
IntBuffer protation,
int debug) |
static PIX |
lept.pixOrientCorrect(PIX pixs,
float minupconf,
float minratio,
FloatPointer pupconf,
FloatPointer pleftconf,
IntPointer protation,
int debug) |
static PIX |
lept.pixOtsuThreshOnBackgroundNorm(PIX pixs,
PIX pixim,
int sx,
int sy,
int thresh,
int mincount,
int bgval,
int smoothx,
int smoothy,
float scorefract,
int[] pthresh) |
static PIX |
lept.pixOtsuThreshOnBackgroundNorm(PIX pixs,
PIX pixim,
int sx,
int sy,
int thresh,
int mincount,
int bgval,
int smoothx,
int smoothy,
float scorefract,
IntBuffer pthresh) |
static PIX |
lept.pixOtsuThreshOnBackgroundNorm(PIX pixs,
PIX pixim,
int sx,
int sy,
int thresh,
int mincount,
int bgval,
int smoothx,
int smoothy,
float scorefract,
IntPointer pthresh) |
static PIX |
lept.pixPadToCenterCentroid(PIX pixs,
int factor) |
static PIX |
lept.pixPaintBoxa(PIX pixs,
BOXA boxa,
int val) |
static PIX |
lept.pixPaintBoxaRandom(PIX pixs,
BOXA boxa) |
static PIX |
lept.pixPrepare1bpp(PIX pixs,
BOX box,
float cropfract,
int outres) |
static PIX |
lept.pixProjective(PIX pixs,
float[] vc,
int incolor) |
static PIX |
lept.pixProjective(PIX pixs,
FloatBuffer vc,
int incolor) |
static PIX |
lept.pixProjective(PIX pixs,
FloatPointer vc,
int incolor) |
static PIX |
lept.pixProjectiveColor(PIX pixs,
float[] vc,
int colorval) |
static PIX |
lept.pixProjectiveColor(PIX pixs,
FloatBuffer vc,
int colorval) |
static PIX |
lept.pixProjectiveColor(PIX pixs,
FloatPointer vc,
int colorval) |
static PIX |
lept.pixProjectiveGray(PIX pixs,
float[] vc,
byte grayval) |
static PIX |
lept.pixProjectiveGray(PIX pixs,
FloatBuffer vc,
byte grayval) |
static PIX |
lept.pixProjectiveGray(PIX pixs,
FloatPointer vc,
byte grayval) |
static PIX |
lept.pixProjectivePta(PIX pixs,
PTA ptad,
PTA ptas,
int incolor) |
static PIX |
lept.pixProjectivePtaColor(PIX pixs,
PTA ptad,
PTA ptas,
int colorval) |
static PIX |
lept.pixProjectivePtaGray(PIX pixs,
PTA ptad,
PTA ptas,
byte grayval) |
static PIX |
lept.pixProjectivePtaWithAlpha(PIX pixs,
PTA ptad,
PTA ptas,
PIX pixg,
float fract,
int border) |
static PIX |
lept.pixProjectiveSampled(PIX pixs,
float[] vc,
int incolor) |
static PIX |
lept.pixProjectiveSampled(PIX pixs,
FloatBuffer vc,
int incolor) |
static PIX |
lept.pixProjectiveSampled(PIX pixs,
FloatPointer vc,
int incolor) |
static PIX |
lept.pixProjectiveSampledPta(PIX pixs,
PTA ptad,
PTA ptas,
int incolor) |
static PIX |
lept.pixQuadraticVShear(PIX pixs,
int dir,
int vmaxt,
int vmaxb,
int operation,
int incolor) |
static PIX |
lept.pixQuadraticVShearLI(PIX pixs,
int dir,
int vmaxt,
int vmaxb,
int incolor) |
static PIX |
lept.pixQuadraticVShearSampled(PIX pixs,
int dir,
int vmaxt,
int vmaxb,
int incolor) |
static PIX |
lept.pixQuantFromCmap(PIX pixs,
PIXCMAP cmap,
int mindepth,
int level,
int metric) |
static PIX |
lept.pixRandomHarmonicWarp(PIX pixs,
float xmag,
float ymag,
float xfreq,
float yfreq,
int nx,
int ny,
int seed,
int grayval) |
static PIX |
lept.pixRankBinByStrip(PIX pixs,
int direction,
int size,
int nbins,
int type) |
static PIX |
lept.pixRankColumnTransform(PIX pixs) |
static PIX |
lept.pixRankFilter(PIX pixs,
int wf,
int hf,
float rank) |
static PIX |
lept.pixRankFilterGray(PIX pixs,
int wf,
int hf,
float rank) |
static PIX |
lept.pixRankFilterRGB(PIX pixs,
int wf,
int hf,
float rank) |
static PIX |
lept.pixRankFilterWithScaling(PIX pixs,
int wf,
int hf,
float rank,
float scalefactor) |
static PIX |
lept.pixRankRowTransform(PIX pixs) |
static PIX |
lept.pixRead(BytePointer filename) |
static PIX |
lept.pixRead(String filename) |
static PIX |
lept.pixReadFromMultipageTiff(BytePointer fname,
SizeTPointer poffset) |
static PIX |
lept.pixReadFromMultipageTiff(String fname,
SizeTPointer poffset) |
static PIX |
lept.pixReadIndexed(SARRAY sa,
int index) |
static PIX |
lept.pixReadJp2k(BytePointer filename,
int reduction,
BOX box,
int hint,
int debug) |
static PIX |
lept.pixReadJp2k(String filename,
int reduction,
BOX box,
int hint,
int debug) |
static PIX |
lept.pixReadJpeg(BytePointer filename,
int cmapflag,
int reduction,
int[] pnwarn,
int hint) |
static PIX |
lept.pixReadJpeg(BytePointer filename,
int cmapflag,
int reduction,
IntBuffer pnwarn,
int hint) |
static PIX |
lept.pixReadJpeg(BytePointer filename,
int cmapflag,
int reduction,
IntPointer pnwarn,
int hint) |
static PIX |
lept.pixReadJpeg(String filename,
int cmapflag,
int reduction,
int[] pnwarn,
int hint) |
static PIX |
lept.pixReadJpeg(String filename,
int cmapflag,
int reduction,
IntBuffer pnwarn,
int hint) |
static PIX |
lept.pixReadJpeg(String filename,
int cmapflag,
int reduction,
IntPointer pnwarn,
int hint) |
static PIX |
lept.pixReadMem(byte[] data,
long size) |
static PIX |
lept.pixReadMem(ByteBuffer data,
long size) |
static PIX |
lept.pixReadMem(BytePointer data,
long size) |
static PIX |
lept.pixReadMemBmp(byte[] cdata,
long size) |
static PIX |
lept.pixReadMemBmp(ByteBuffer cdata,
long size) |
static PIX |
lept.pixReadMemBmp(BytePointer cdata,
long size) |
static PIX |
lept.pixReadMemFromMultipageTiff(byte[] cdata,
long size,
SizeTPointer poffset) |
static PIX |
lept.pixReadMemFromMultipageTiff(ByteBuffer cdata,
long size,
SizeTPointer poffset) |
static PIX |
lept.pixReadMemFromMultipageTiff(BytePointer cdata,
long size,
SizeTPointer poffset) |
static PIX |
lept.pixReadMemGif(byte[] cdata,
long size) |
static PIX |
lept.pixReadMemGif(ByteBuffer cdata,
long size) |
static PIX |
lept.pixReadMemGif(BytePointer cdata,
long size) |
static PIX |
lept.pixReadMemJp2k(byte[] data,
long size,
int reduction,
BOX box,
int hint,
int debug) |
static PIX |
lept.pixReadMemJp2k(ByteBuffer data,
long size,
int reduction,
BOX box,
int hint,
int debug) |
static PIX |
lept.pixReadMemJp2k(BytePointer data,
long size,
int reduction,
BOX box,
int hint,
int debug) |
static PIX |
lept.pixReadMemJpeg(byte[] data,
long size,
int cmflag,
int reduction,
int[] pnwarn,
int hint) |
static PIX |
lept.pixReadMemJpeg(ByteBuffer data,
long size,
int cmflag,
int reduction,
IntBuffer pnwarn,
int hint) |
static PIX |
lept.pixReadMemJpeg(BytePointer data,
long size,
int cmflag,
int reduction,
IntPointer pnwarn,
int hint) |
static PIX |
lept.pixReadMemPng(byte[] filedata,
long filesize) |
static PIX |
lept.pixReadMemPng(ByteBuffer filedata,
long filesize) |
static PIX |
lept.pixReadMemPng(BytePointer filedata,
long filesize) |
static PIX |
lept.pixReadMemPnm(byte[] data,
long size) |
static PIX |
lept.pixReadMemPnm(ByteBuffer data,
long size) |
static PIX |
lept.pixReadMemPnm(BytePointer data,
long size) |
static PIX |
lept.pixReadMemSpix(byte[] data,
long size) |
static PIX |
lept.pixReadMemSpix(ByteBuffer data,
long size) |
static PIX |
lept.pixReadMemSpix(BytePointer data,
long size) |
static PIX |
lept.pixReadMemTiff(byte[] cdata,
long size,
int n) |
static PIX |
lept.pixReadMemTiff(ByteBuffer cdata,
long size,
int n) |
static PIX |
lept.pixReadMemTiff(BytePointer cdata,
long size,
int n) |
static PIX |
lept.pixReadMemWebP(byte[] filedata,
long filesize) |
static PIX |
lept.pixReadMemWebP(ByteBuffer filedata,
long filesize) |
static PIX |
lept.pixReadMemWebP(BytePointer filedata,
long filesize) |
static PIX |
lept.pixReadStream(Pointer fp,
int hint) |
static PIX |
lept.pixReadStreamBmp(Pointer fp) |
static PIX |
lept.pixReadStreamGif(Pointer fp) |
static PIX |
lept.pixReadStreamJp2k(Pointer fp,
int reduction,
BOX box,
int hint,
int debug) |
static PIX |
lept.pixReadStreamJpeg(Pointer fp,
int cmapflag,
int reduction,
int[] pnwarn,
int hint) |
static PIX |
lept.pixReadStreamJpeg(Pointer fp,
int cmapflag,
int reduction,
IntBuffer pnwarn,
int hint) |
static PIX |
lept.pixReadStreamJpeg(Pointer fp,
int cmapflag,
int reduction,
IntPointer pnwarn,
int hint) |
static PIX |
lept.pixReadStreamPng(Pointer fp) |
static PIX |
lept.pixReadStreamPnm(Pointer fp) |
static PIX |
lept.pixReadStreamSpix(Pointer fp) |
static PIX |
lept.pixReadStreamTiff(Pointer fp,
int n) |
static PIX |
lept.pixReadStreamWebP(Pointer fp) |
static PIX |
lept.pixReadTiff(BytePointer filename,
int n) |
static PIX |
lept.pixReadTiff(String filename,
int n) |
static PIX |
lept.pixReadWithHint(BytePointer filename,
int hint) |
static PIX |
lept.pixReadWithHint(String filename,
int hint) |
static PIX |
lept.pixReduceBinary2(PIX pixs,
byte[] intab) |
static PIX |
lept.pixReduceBinary2(PIX pixs,
ByteBuffer intab) |
static PIX |
lept.pixReduceBinary2(PIX pixs,
BytePointer intab) |
static PIX |
lept.pixReduceRankBinary2(PIX pixs,
int level,
byte[] intab) |
static PIX |
lept.pixReduceRankBinary2(PIX pixs,
int level,
ByteBuffer intab) |
static PIX |
lept.pixReduceRankBinary2(PIX pixs,
int level,
BytePointer intab) |
static PIX |
lept.pixReduceRankBinaryCascade(PIX pixs,
int level1,
int level2,
int level3,
int level4) |
static PIX |
lept.pixRemoveAlpha(PIX pixs) |
static PIX |
lept.pixRemoveBorder(PIX pixs,
int npix) |
static PIX |
lept.pixRemoveBorderConnComps(PIX pixs,
int connectivity) |
static PIX |
lept.pixRemoveBorderGeneral(PIX pixs,
int left,
int right,
int top,
int bot) |
static PIX |
lept.pixRemoveBorderToSize(PIX pixs,
int wd,
int hd) |
static PIX |
lept.pixRemoveColormap(PIX pixs,
int type) |
static PIX |
lept.pixRemoveColormapGeneral(PIX pixs,
int type,
int ifnocmap) |
static PIX |
lept.pixRemoveSeededComponents(PIX pixd,
PIX pixs,
PIX pixm,
int connectivity,
int bordersize) |
static PIX |
lept.pixRenderContours(PIX pixs,
int startval,
int incr,
int outdepth) |
static PIX |
lept.pixRenderPolygon(PTA ptas,
int width,
int[] pxmin,
int[] pymin) |
static PIX |
lept.pixRenderPolygon(PTA ptas,
int width,
IntBuffer pxmin,
IntBuffer pymin) |
static PIX |
lept.pixRenderPolygon(PTA ptas,
int width,
IntPointer pxmin,
IntPointer pymin) |
static PIX |
lept.pixRenderRandomCmapPtaa(PIX pix,
PTAA ptaa,
int polyflag,
int width,
int closeflag) |
static PIX |
lept.pixResizeToMatch(PIX pixs,
PIX pixt,
int w,
int h) |
static PIX |
lept.pixRotate(PIX pixs,
float angle,
int type,
int incolor,
int width,
int height) |
static PIX |
lept.pixRotate180(PIX pixd,
PIX pixs) |
static PIX |
lept.pixRotate2Shear(PIX pixs,
int xcen,
int ycen,
float angle,
int incolor) |
static PIX |
lept.pixRotate3Shear(PIX pixs,
int xcen,
int ycen,
float angle,
int incolor) |
static PIX |
lept.pixRotate90(PIX pixs,
int direction) |
static PIX |
lept.pixRotateAM(PIX pixs,
float angle,
int incolor) |
static PIX |
lept.pixRotateAMColor(PIX pixs,
float angle,
int colorval) |
static PIX |
lept.pixRotateAMColorCorner(PIX pixs,
float angle,
int fillval) |
static PIX |
lept.pixRotateAMColorFast(PIX pixs,
float angle,
int colorval) |
static PIX |
lept.pixRotateAMCorner(PIX pixs,
float angle,
int incolor) |
static PIX |
lept.pixRotateAMGray(PIX pixs,
float angle,
byte grayval) |
static PIX |
lept.pixRotateAMGrayCorner(PIX pixs,
float angle,
byte grayval) |
static PIX |
lept.pixRotateBinaryNice(PIX pixs,
float angle,
int incolor) |
static PIX |
lept.pixRotateBySampling(PIX pixs,
int xcen,
int ycen,
float angle,
int incolor) |
static PIX |
lept.pixRotateOrth(PIX pixs,
int quads) |
static PIX |
lept.pixRotateShear(PIX pixs,
int xcen,
int ycen,
float angle,
int incolor) |
static PIX |
lept.pixRotateShearCenter(PIX pixs,
float angle,
int incolor) |
static PIX |
lept.pixRotateWithAlpha(PIX pixs,
float angle,
PIX pixg,
float fract) |
static PIX |
lept.pixRunlengthTransform(PIX pixs,
int color,
int direction,
int depth) |
static PIX |
lept.pixSauvolaOnContrastNorm(PIX pixs,
int mindiff,
PIX ppixn,
PIX ppixth) |
static PIX |
lept.pixSauvolaOnContrastNorm(PIX pixs,
int mindiff,
PointerPointer ppixn,
PointerPointer ppixth) |
static PIX |
lept.pixScale(PIX pixs,
float scalex,
float scaley) |
static PIX |
lept.pixScaleAreaMap(PIX pix,
float scalex,
float scaley) |
static PIX |
lept.pixScaleAreaMap2(PIX pix) |
static PIX |
lept.pixScaleAreaMapToSize(PIX pixs,
int wd,
int hd) |
static PIX |
lept.pixScaleBinary(PIX pixs,
float scalex,
float scaley) |
static PIX |
lept.pixScaleByIntSampling(PIX pixs,
int factor) |
static PIX |
lept.pixScaleBySampling(PIX pixs,
float scalex,
float scaley) |
static PIX |
lept.pixScaleBySamplingToSize(PIX pixs,
int wd,
int hd) |
static PIX |
lept.pixScaleColor2xLI(PIX pixs) |
static PIX |
lept.pixScaleColor4xLI(PIX pixs) |
static PIX |
lept.pixScaleColorLI(PIX pixs,
float scalex,
float scaley) |
static PIX |
lept.pixScaleGeneral(PIX pixs,
float scalex,
float scaley,
float sharpfract,
int sharpwidth) |
static PIX |
lept.pixScaleGray2xLI(PIX pixs) |
static PIX |
lept.pixScaleGray2xLIDither(PIX pixs) |
static PIX |
lept.pixScaleGray2xLIThresh(PIX pixs,
int thresh) |
static PIX |
lept.pixScaleGray4xLI(PIX pixs) |
static PIX |
lept.pixScaleGray4xLIDither(PIX pixs) |
static PIX |
lept.pixScaleGray4xLIThresh(PIX pixs,
int thresh) |
static PIX |
lept.pixScaleGrayLI(PIX pixs,
float scalex,
float scaley) |
static PIX |
lept.pixScaleGrayMinMax(PIX pixs,
int xfact,
int yfact,
int type) |
static PIX |
lept.pixScaleGrayMinMax2(PIX pixs,
int type) |
static PIX |
lept.pixScaleGrayRank2(PIX pixs,
int rank) |
static PIX |
lept.pixScaleGrayRankCascade(PIX pixs,
int level1,
int level2,
int level3,
int level4) |
static PIX |
lept.pixScaleGrayToBinaryFast(PIX pixs,
int factor,
int thresh) |
static PIX |
lept.pixScaleLI(PIX pixs,
float scalex,
float scaley) |
static PIX |
lept.pixScaleMipmap(PIX pixs1,
PIX pixs2,
float scale) |
static PIX |
lept.pixScaleRGBToBinaryFast(PIX pixs,
int factor,
int thresh) |
static PIX |
lept.pixScaleRGBToGray2(PIX pixs,
float rwt,
float gwt,
float bwt) |
static PIX |
lept.pixScaleRGBToGrayFast(PIX pixs,
int factor,
int color) |
static PIX |
lept.pixScaleSmooth(PIX pix,
float scalex,
float scaley) |
static PIX |
lept.pixScaleSmoothToSize(PIX pixs,
int wd,
int hd) |
static PIX |
lept.pixScaleToGray(PIX pixs,
float scalefactor) |
static PIX |
lept.pixScaleToGray16(PIX pixs) |
static PIX |
lept.pixScaleToGray2(PIX pixs) |
static PIX |
lept.pixScaleToGray3(PIX pixs) |
static PIX |
lept.pixScaleToGray4(PIX pixs) |
static PIX |
lept.pixScaleToGray6(PIX pixs) |
static PIX |
lept.pixScaleToGray8(PIX pixs) |
static PIX |
lept.pixScaleToGrayFast(PIX pixs,
float scalefactor) |
static PIX |
lept.pixScaleToGrayMipmap(PIX pixs,
float scalefactor) |
static PIX |
lept.pixScaleToResolution(PIX pixs,
float target,
float assumed,
float[] pscalefact) |
static PIX |
lept.pixScaleToResolution(PIX pixs,
float target,
float assumed,
FloatBuffer pscalefact) |
static PIX |
lept.pixScaleToResolution(PIX pixs,
float target,
float assumed,
FloatPointer pscalefact) |
static PIX |
lept.pixScaleToSize(PIX pixs,
int wd,
int hd) |
static PIX |
lept.pixScaleToSizeRel(PIX pixs,
int delw,
int delh) |
static PIX |
lept.pixScaleWithAlpha(PIX pixs,
float scalex,
float scaley,
PIX pixg,
float fract) |
static PIX |
lept.pixSeedfillBinary(PIX pixd,
PIX pixs,
PIX pixm,
int connectivity) |
static PIX |
lept.pixSeedfillBinaryRestricted(PIX pixd,
PIX pixs,
PIX pixm,
int connectivity,
int xmax,
int ymax) |
static PIX |
lept.pixSeedfillGrayBasin(PIX pixb,
PIX pixm,
int delta,
int connectivity) |
static PIX |
lept.pixSeedfillMorph(PIX pixs,
PIX pixm,
int maxiters,
int connectivity) |
static PIX |
lept.pixSeedspread(PIX pixs,
int connectivity) |
static PIX |
lept.pixSelectByArea(PIX pixs,
float thresh,
int connectivity,
int type,
int[] pchanged) |
static PIX |
lept.pixSelectByArea(PIX pixs,
float thresh,
int connectivity,
int type,
IntBuffer pchanged) |
static PIX |
lept.pixSelectByArea(PIX pixs,
float thresh,
int connectivity,
int type,
IntPointer pchanged) |
static PIX |
lept.pixSelectByAreaFraction(PIX pixs,
float thresh,
int connectivity,
int type,
int[] pchanged) |
static PIX |
lept.pixSelectByAreaFraction(PIX pixs,
float thresh,
int connectivity,
int type,
IntBuffer pchanged) |
static PIX |
lept.pixSelectByAreaFraction(PIX pixs,
float thresh,
int connectivity,
int type,
IntPointer pchanged) |
static PIX |
lept.pixSelectByPerimSizeRatio(PIX pixs,
float thresh,
int connectivity,
int type,
int[] pchanged) |
static PIX |
lept.pixSelectByPerimSizeRatio(PIX pixs,
float thresh,
int connectivity,
int type,
IntBuffer pchanged) |
static PIX |
lept.pixSelectByPerimSizeRatio(PIX pixs,
float thresh,
int connectivity,
int type,
IntPointer pchanged) |
static PIX |
lept.pixSelectByPerimToAreaRatio(PIX pixs,
float thresh,
int connectivity,
int type,
int[] pchanged) |
static PIX |
lept.pixSelectByPerimToAreaRatio(PIX pixs,
float thresh,
int connectivity,
int type,
IntBuffer pchanged) |
static PIX |
lept.pixSelectByPerimToAreaRatio(PIX pixs,
float thresh,
int connectivity,
int type,
IntPointer pchanged) |
static PIX |
lept.pixSelectBySize(PIX pixs,
int width,
int height,
int connectivity,
int type,
int relation,
int[] pchanged) |
static PIX |
lept.pixSelectBySize(PIX pixs,
int width,
int height,
int connectivity,
int type,
int relation,
IntBuffer pchanged) |
static PIX |
lept.pixSelectBySize(PIX pixs,
int width,
int height,
int connectivity,
int type,
int relation,
IntPointer pchanged) |
static PIX |
lept.pixSelectByWidthHeightRatio(PIX pixs,
float thresh,
int connectivity,
int type,
int[] pchanged) |
static PIX |
lept.pixSelectByWidthHeightRatio(PIX pixs,
float thresh,
int connectivity,
int type,
IntBuffer pchanged) |
static PIX |
lept.pixSelectByWidthHeightRatio(PIX pixs,
float thresh,
int connectivity,
int type,
IntPointer pchanged) |
static PIX |
lept.pixSelectComponentBySize(PIX pixs,
int rankorder,
int type,
int connectivity,
BOX pbox) |
static PIX |
lept.pixSelectComponentBySize(PIX pixs,
int rankorder,
int type,
int connectivity,
PointerPointer pbox) |
static PIX |
lept.pixSelectiveConnCompFill(PIX pixs,
int connectivity,
int minw,
int minh) |
static PIX |
lept.pixSetAlphaOverWhite(PIX pixs) |
static PIX |
lept.pixSetBlackOrWhiteBoxa(PIX pixs,
BOXA boxa,
int op) |
static PIX |
lept.pixSetStrokeWidth(PIX pixs,
int width,
int thinfirst,
int connectivity) |
static PIX |
lept.pixSetUnderTransparency(PIX pixs,
int val,
int debug) |
static PIX |
lept.pixShiftByComponent(PIX pixd,
PIX pixs,
int srcval,
int dstval) |
static PIX |
lept.pixSimpleCaptcha(PIX pixs,
int border,
int nterms,
int seed,
int color,
int cmapflag) |
static PIX |
lept.pixSimpleColorQuantize(PIX pixs,
int sigbits,
int factor,
int ncolors) |
static PIX |
lept.pixSnapColor(PIX pixd,
PIX pixs,
int srcval,
int dstval,
int diff) |
static PIX |
lept.pixSnapColorCmap(PIX pixd,
PIX pixs,
int srcval,
int dstval,
int diff) |
static PIX |
lept.pixSobelEdgeFilter(PIX pixs,
int orientflag) |
static PIX |
lept.pixStereoFromPair(PIX pix1,
PIX pix2,
float rwt,
float gwt,
float bwt) |
static PIX |
lept.pixStretchHorizontal(PIX pixs,
int dir,
int type,
int hmax,
int operation,
int incolor) |
static PIX |
lept.pixStretchHorizontalLI(PIX pixs,
int dir,
int type,
int hmax,
int incolor) |
static PIX |
lept.pixStretchHorizontalSampled(PIX pixs,
int dir,
int type,
int hmax,
int incolor) |
static PIX |
lept.pixStrokeWidthTransform(PIX pixs,
int color,
int depth,
int nangles) |
static PIX |
lept.pixSubtract(PIX pixd,
PIX pixs1,
PIX pixs2) |
static PIX |
lept.pixSubtractGray(PIX pixd,
PIX pixs1,
PIX pixs2) |
static PIX |
lept.pixThinConnected(PIX pixs,
int type,
int connectivity,
int maxiters) |
static PIX |
lept.pixThinConnectedBySet(PIX pixs,
int type,
SELA sela,
int maxiters) |
static PIX |
lept.pixThreshold8(PIX pixs,
int d,
int nlevels,
int cmapflag) |
static PIX |
lept.pixThresholdGrayArb(PIX pixs,
BytePointer edgevals,
int outdepth,
int use_average,
int setblack,
int setwhite) |
static PIX |
lept.pixThresholdGrayArb(PIX pixs,
String edgevals,
int outdepth,
int use_average,
int setblack,
int setwhite) |
static PIX |
lept.pixThresholdOn8bpp(PIX pixs,
int nlevels,
int cmapflag) |
static PIX |
lept.pixThresholdTo2bpp(PIX pixs,
int nlevels,
int cmapflag) |
static PIX |
lept.pixThresholdTo4bpp(PIX pixs,
int nlevels,
int cmapflag) |
static PIX |
lept.pixThresholdToBinary(PIX pixs,
int thresh) |
static PIX |
lept.pixThresholdToValue(PIX pixd,
PIX pixs,
int threshval,
int setval) |
static PIX |
lept.pixThreshOnDoubleNorm(PIX pixs,
int mindiff) |
static PIX |
lept.pixTilingGetTile(PIXTILING pt,
int i,
int j) |
static PIX |
lept.pixTophat(PIX pixs,
int hsize,
int vsize,
int type) |
static PIX |
lept.pixTranslate(PIX pixd,
PIX pixs,
int hshift,
int vshift,
int incolor) |
static PIX |
lept.pixTwoSidedEdgeFilter(PIX pixs,
int orientflag) |
static PIX |
lept.pixUnionOfMorphOps(PIX pixs,
SELA sela,
int type) |
static PIX |
lept.pixUnpackBinary(PIX pixs,
int depth,
int invert) |
static PIX |
lept.pixUnsharpMasking(PIX pixs,
int halfwidth,
float fract) |
static PIX |
lept.pixUnsharpMaskingFast(PIX pixs,
int halfwidth,
float fract,
int direction) |
static PIX |
lept.pixUnsharpMaskingGray(PIX pixs,
int halfwidth,
float fract) |
static PIX |
lept.pixUnsharpMaskingGray1D(PIX pixs,
int halfwidth,
float fract,
int direction) |
static PIX |
lept.pixUnsharpMaskingGray2D(PIX pixs,
int halfwidth,
float fract) |
static PIX |
lept.pixUnsharpMaskingGrayFast(PIX pixs,
int halfwidth,
float fract,
int direction) |
static PIX |
lept.pixVarThresholdToBinary(PIX pixs,
PIX pixg) |
static PIX |
lept.pixVShear(PIX pixd,
PIX pixs,
int xloc,
float radang,
int incolor) |
static PIX |
lept.pixVShearCenter(PIX pixd,
PIX pixs,
float radang,
int incolor) |
static PIX |
lept.pixVShearCorner(PIX pixd,
PIX pixs,
float radang,
int incolor) |
static PIX |
lept.pixVShearLI(PIX pixs,
int xloc,
float radang,
int incolor) |
static PIX |
lept.pixWarpStereoscopic(PIX pixs,
int zbend,
int zshiftt,
int zshiftb,
int ybendt,
int ybendb,
int redleft) |
static PIX |
lept.pixWindowedMean(PIX pixs,
int wc,
int hc,
int hasborder,
int normflag) |
static PIX |
lept.pixWindowedMeanSquare(PIX pixs,
int wc,
int hc,
int hasborder) |
static PIX |
lept.pixXor(PIX pixd,
PIX pixs1,
PIX pixs2) |
static PIX |
lept.recogModifyTemplate(L_RECOG recog,
PIX pixs) |
static PIX |
lept.recogProcessToIdentify(L_RECOG recog,
PIX pixs,
int pad) |
static PIX |
lept.recogShowMatch(L_RECOG recog,
PIX pix1,
PIX pix2,
BOX box,
int index,
float score) |
static PIX |
lept.selaDisplayInPix(SELA sela,
int size,
int gthick,
int spacing,
int ncols) |
static PIX |
lept.selDisplayInPix(SEL sel,
int size,
int gthick) |
static PIX |
lept.wshedRenderColors(L_WSHED wshed) |
static PIX |
lept.wshedRenderFill(L_WSHED wshed) |
Modifier and Type | Method and Description |
---|---|
static int |
lept.adjacentOnPixelInRaster(PIX pixs,
int x,
int y,
int[] pxa,
int[] pya) |
static int |
lept.adjacentOnPixelInRaster(PIX pixs,
int x,
int y,
IntBuffer pxa,
IntBuffer pya) |
static int |
lept.adjacentOnPixelInRaster(PIX pixs,
int x,
int y,
IntPointer pxa,
IntPointer pya) |
static PIX |
lept.boxaaDisplay(PIX pixs,
BOXAA baa,
int linewba,
int linewb,
int colorba,
int colorb,
int w,
int h) |
static int |
lept.boxaCompareRegions(BOXA boxa1,
BOXA boxa2,
int areathresh,
int[] pnsame,
float[] pdiffarea,
float[] pdiffxor,
PIX ppixdb) |
static int |
lept.boxaCompareRegions(BOXA boxa1,
BOXA boxa2,
int areathresh,
IntBuffer pnsame,
FloatBuffer pdiffarea,
FloatBuffer pdiffxor,
PIX ppixdb) |
static int |
lept.boxaCompareRegions(BOXA boxa1,
BOXA boxa2,
int areathresh,
IntPointer pnsame,
FloatPointer pdiffarea,
FloatPointer pdiffxor,
PIX ppixdb) |
static int |
lept.boxaPlotSides(BOXA boxa,
BytePointer plotname,
NUMA pnal,
NUMA pnat,
NUMA pnar,
NUMA pnab,
PIX ppixd) |
static int |
lept.boxaPlotSides(BOXA boxa,
String plotname,
NUMA pnal,
NUMA pnat,
NUMA pnar,
NUMA pnab,
PIX ppixd) |
static int |
lept.boxaPlotSizes(BOXA boxa,
BytePointer plotname,
NUMA pnaw,
NUMA pnah,
PIX ppixd) |
static int |
lept.boxaPlotSizes(BOXA boxa,
String plotname,
NUMA pnaw,
NUMA pnah,
PIX ppixd) |
static CCBORDA |
lept.ccbaCreate(PIX pixs,
int n) |
static CCBORD |
lept.ccbCreate(PIX pixs) |
static int |
lept.dewarpaApplyDisparity(L_DEWARPA dewa,
int pageno,
PIX pixs,
int grayin,
int x,
int y,
PIX ppixd,
BytePointer debugfile) |
static int |
lept.dewarpaApplyDisparity(L_DEWARPA dewa,
int pageno,
PIX pixs,
int grayin,
int x,
int y,
PIX ppixd,
String debugfile) |
static int |
lept.dewarpaApplyDisparity(L_DEWARPA dewa,
int pageno,
PIX pixs,
int grayin,
int x,
int y,
PointerPointer ppixd,
BytePointer debugfile) |
static int |
lept.dewarpaApplyDisparityBoxa(L_DEWARPA dewa,
int pageno,
PIX pixs,
BOXA boxas,
int mapdir,
int x,
int y,
BOXA pboxad,
BytePointer debugfile) |
static int |
lept.dewarpaApplyDisparityBoxa(L_DEWARPA dewa,
int pageno,
PIX pixs,
BOXA boxas,
int mapdir,
int x,
int y,
BOXA pboxad,
String debugfile) |
static int |
lept.dewarpaApplyDisparityBoxa(L_DEWARPA dewa,
int pageno,
PIX pixs,
BOXA boxas,
int mapdir,
int x,
int y,
PointerPointer pboxad,
BytePointer debugfile) |
static L_DEWARP |
lept.dewarpCreate(PIX pixs,
int pageno) |
static int |
lept.dewarpFindHorizSlopeDisparity(L_DEWARP dew,
PIX pixb,
float fractthresh,
int parity) |
static PTAA |
lept.dewarpGetTextlineCenters(PIX pixs,
int debugflag) |
static int |
lept.dewarpPopulateFullRes(L_DEWARP dew,
PIX pix,
int x,
int y) |
static PTAA |
lept.dewarpRemoveShortLines(PIX pixs,
PTAA ptaas,
float fract,
int debugflag) |
static int |
lept.dewarpSinglePage(PIX pixs,
int thresh,
int adaptive,
int useboth,
int check_columns,
PIX ppixd,
L_DEWARPA pdewa,
int debug) |
static int |
lept.dewarpSinglePage(PIX pixs,
int thresh,
int adaptive,
int useboth,
int check_columns,
PointerPointer ppixd,
PointerPointer pdewa,
int debug) |
static int |
lept.dewarpSinglePageInit(PIX pixs,
int thresh,
int adaptive,
int useboth,
int check_columns,
PIX ppixb,
L_DEWARPA pdewa) |
static int |
lept.dewarpSinglePageInit(PIX pixs,
int thresh,
int adaptive,
int useboth,
int check_columns,
PointerPointer ppixb,
PointerPointer pdewa) |
static int |
lept.dewarpSinglePageRun(PIX pixs,
PIX pixb,
L_DEWARPA dewa,
PIX ppixd,
int debug) |
static int |
lept.dewarpSinglePageRun(PIX pixs,
PIX pixb,
L_DEWARPA dewa,
PointerPointer ppixd,
int debug) |
static PTA |
lept.getCutPathForHole(PIX pix,
PTA pta,
BOX boxinner,
int[] pdir,
int[] plen) |
static PTA |
lept.getCutPathForHole(PIX pix,
PTA pta,
BOX boxinner,
IntBuffer pdir,
IntBuffer plen) |
static PTA |
lept.getCutPathForHole(PIX pix,
PTA pta,
BOX boxinner,
IntPointer pdir,
IntPointer plen) |
static int |
lept.jbAddPage(JBCLASSER classer,
PIX pixs) |
static int |
lept.jbAddPageComponents(JBCLASSER classer,
PIX pixs,
BOXA boxas,
PIXA pixas) |
static int |
lept.jbGetComponents(PIX pixs,
int components,
int maxwidth,
int maxheight,
BOXA pboxad,
PIXA ppixad) |
static int |
lept.jbGetComponents(PIX pixs,
int components,
int maxwidth,
int maxheight,
PointerPointer pboxad,
PointerPointer ppixad) |
static int |
lept.jbGetULCorners(JBCLASSER classer,
PIX pixs,
BOXA boxa) |
static L_KERNEL |
lept.kernelCreateFromPix(PIX pix,
int cy,
int cx) |
static L_COLORFILL |
lept.l_colorfillCreate(PIX pixs,
int nx,
int ny) |
static int |
lept.l_generateCIDataForPdf(BytePointer fname,
PIX pix,
int quality,
L_COMP_DATA pcid) |
static int |
lept.l_generateCIDataForPdf(BytePointer fname,
PIX pix,
int quality,
PointerPointer pcid) |
static int |
lept.l_generateCIDataForPdf(String fname,
PIX pix,
int quality,
L_COMP_DATA pcid) |
static L_COMP_DATA |
lept.l_generateFlateDataPdf(BytePointer fname,
PIX pixs) |
static L_COMP_DATA |
lept.l_generateFlateDataPdf(String fname,
PIX pixs) |
static int |
lept.nextOnPixelInRaster(PIX pixs,
int xstart,
int ystart,
int[] px,
int[] py) |
static int |
lept.nextOnPixelInRaster(PIX pixs,
int xstart,
int ystart,
IntBuffer px,
IntBuffer py) |
static int |
lept.nextOnPixelInRaster(PIX pixs,
int xstart,
int ystart,
IntPointer px,
IntPointer py) |
static NUMA |
lept.numaEqualizeTRC(PIX pix,
float fract,
int factor) |
static int |
lept.pixaaAddPix(PIXAA paa,
int index,
PIX pix,
BOX box,
int copyflag) |
static int |
lept.pixaAccumulateSamples(PIXA pixa,
PTA pta,
PIX ppixd,
float[] px,
float[] py) |
static int |
lept.pixaAccumulateSamples(PIXA pixa,
PTA pta,
PIX ppixd,
FloatBuffer px,
FloatBuffer py) |
static int |
lept.pixaAccumulateSamples(PIXA pixa,
PTA pta,
PIX ppixd,
FloatPointer px,
FloatPointer py) |
static int |
lept.pixaAddPix(PIXA pixa,
PIX pix,
int copyflag) |
static int |
lept.pixaAddPixWithText(PIXA pixa,
PIX pixs,
int reduction,
L_BMF bmf,
BytePointer textstr,
int val,
int location) |
static int |
lept.pixaAddPixWithText(PIXA pixa,
PIX pixs,
int reduction,
L_BMF bmf,
String textstr,
int val,
int location) |
static NUMA |
lept.pixAbsDiffByColumn(PIX pix,
BOX box) |
static NUMA |
lept.pixAbsDiffByRow(PIX pix,
BOX box) |
static PIX |
lept.pixAbsDifference(PIX pixs1,
PIX pixs2) |
static int |
lept.pixAbsDiffInRect(PIX pix,
BOX box,
int dir,
float[] pabsdiff) |
static int |
lept.pixAbsDiffInRect(PIX pix,
BOX box,
int dir,
FloatBuffer pabsdiff) |
static int |
lept.pixAbsDiffInRect(PIX pix,
BOX box,
int dir,
FloatPointer pabsdiff) |
static int |
lept.pixAbsDiffOnLine(PIX pix,
int x1,
int y1,
int x2,
int y2,
float[] pabsdiff) |
static int |
lept.pixAbsDiffOnLine(PIX pix,
int x1,
int y1,
int x2,
int y2,
FloatBuffer pabsdiff) |
static int |
lept.pixAbsDiffOnLine(PIX pix,
int x1,
int y1,
int x2,
int y2,
FloatPointer pabsdiff) |
static int |
lept.pixaccAdd(PIXACC pixacc,
PIX pix) |
static PIXACC |
lept.pixaccCreateFromPix(PIX pix,
int negflag) |
static int |
lept.pixaccMultConstAccumulate(PIXACC pixacc,
PIX pix,
float factor) |
static int |
lept.pixaccSubtract(PIXACC pixacc,
PIX pix) |
static int |
lept.pixAccumulate(PIX pixd,
PIX pixs,
int op) |
static PIXA |
lept.pixaClipToPix(PIXA pixas,
PIX pixs) |
static int |
lept.pixacompAddPix(PIXAC pixac,
PIX pix,
int comptype) |
static int |
lept.pixaComparePhotoRegionsByHisto(PIXA pixa,
float minratio,
float textthresh,
int factor,
int n,
float simthresh,
NUMA pnai,
float[] pscores,
PIX ppixd,
int debug) |
static int |
lept.pixaComparePhotoRegionsByHisto(PIXA pixa,
float minratio,
float textthresh,
int factor,
int n,
float simthresh,
NUMA pnai,
FloatBuffer pscores,
PIX ppixd,
int debug) |
static int |
lept.pixaComparePhotoRegionsByHisto(PIXA pixa,
float minratio,
float textthresh,
int factor,
int n,
float simthresh,
NUMA pnai,
FloatPointer pscores,
PIX ppixd,
int debug) |
static PIXAC |
lept.pixacompCreateWithInit(int n,
int offset,
PIX pix,
int comptype) |
static int |
lept.pixacompReplacePix(PIXAC pixac,
int index,
PIX pix,
int comptype) |
static PIXA |
lept.pixaCreateFromBoxa(PIX pixs,
BOXA boxa,
int start,
int num,
int[] pcropwarn) |
static PIXA |
lept.pixaCreateFromBoxa(PIX pixs,
BOXA boxa,
int start,
int num,
IntBuffer pcropwarn) |
static PIXA |
lept.pixaCreateFromBoxa(PIX pixs,
BOXA boxa,
int start,
int num,
IntPointer pcropwarn) |
static PIXA |
lept.pixaCreateFromPix(PIX pixs,
int n,
int cellw,
int cellh) |
static PIX |
lept.pixAdaptThresholdToBinary(PIX pixs,
PIX pixm,
float gamma) |
static PIX |
lept.pixAdaptThresholdToBinaryGen(PIX pixs,
PIX pixm,
float gamma,
int blackval,
int whiteval,
int thresh) |
static PIX |
lept.pixAddAlphaTo1bpp(PIX pixd,
PIX pixs) |
static PIX |
lept.pixAddAlphaToBlend(PIX pixs,
float fract,
int invert) |
static PIX |
lept.pixAddBlackOrWhiteBorder(PIX pixs,
int left,
int right,
int top,
int bot,
int op) |
static PIX |
lept.pixAddBorder(PIX pixs,
int npix,
int val) |
static PIX |
lept.pixAddBorderGeneral(PIX pixs,
int left,
int right,
int top,
int bot,
int val) |
static int |
lept.pixAddConstantGray(PIX pixs,
int val) |
static PIX |
lept.pixAddContinuedBorder(PIX pixs,
int left,
int right,
int top,
int bot) |
static PIX |
lept.pixAddGaussianNoise(PIX pixs,
float stdev) |
static PIX |
lept.pixAddGray(PIX pixd,
PIX pixs1,
PIX pixs2) |
static int |
lept.pixAddGrayColormap8(PIX pixs) |
static PIX |
lept.pixAddMinimalGrayColormap8(PIX pixs) |
static PIX |
lept.pixAddMirroredBorder(PIX pixs,
int left,
int right,
int top,
int bot) |
static PIX |
lept.pixAddMixedBorder(PIX pixs,
int left,
int right,
int top,
int bot) |
static PIX |
lept.pixAddRepeatedBorder(PIX pixs,
int left,
int right,
int top,
int bot) |
static PIX |
lept.pixAddRGB(PIX pixs1,
PIX pixs2) |
static PIX |
lept.pixAddSingleTextblock(PIX pixs,
L_BMF bmf,
BytePointer textstr,
int val,
int location,
int[] poverflow) |
static PIX |
lept.pixAddSingleTextblock(PIX pixs,
L_BMF bmf,
BytePointer textstr,
int val,
int location,
IntBuffer poverflow) |
static PIX |
lept.pixAddSingleTextblock(PIX pixs,
L_BMF bmf,
BytePointer textstr,
int val,
int location,
IntPointer poverflow) |
static PIX |
lept.pixAddSingleTextblock(PIX pixs,
L_BMF bmf,
String textstr,
int val,
int location,
int[] poverflow) |
static PIX |
lept.pixAddSingleTextblock(PIX pixs,
L_BMF bmf,
String textstr,
int val,
int location,
IntBuffer poverflow) |
static PIX |
lept.pixAddSingleTextblock(PIX pixs,
L_BMF bmf,
String textstr,
int val,
int location,
IntPointer poverflow) |
static int |
lept.pixAddText(PIX pix,
BytePointer textstring) |
static int |
lept.pixAddText(PIX pix,
String textstring) |
static PIX |
lept.pixAddTextlines(PIX pixs,
L_BMF bmf,
BytePointer textstr,
int val,
int location) |
static PIX |
lept.pixAddTextlines(PIX pixs,
L_BMF bmf,
String textstr,
int val,
int location) |
static int |
lept.pixAddWithIndicator(PIX pixs,
PIXA pixa,
NUMA na) |
static int |
lept.pixaExtractColumnFromEachPix(PIXA pixa,
int col,
PIX pixd) |
static PIX |
lept.pixAffine(PIX pixs,
float[] vc,
int incolor) |
static PIX |
lept.pixAffine(PIX pixs,
FloatBuffer vc,
int incolor) |
static PIX |
lept.pixAffine(PIX pixs,
FloatPointer vc,
int incolor) |
static PIX |
lept.pixAffineColor(PIX pixs,
float[] vc,
int colorval) |
static PIX |
lept.pixAffineColor(PIX pixs,
FloatBuffer vc,
int colorval) |
static PIX |
lept.pixAffineColor(PIX pixs,
FloatPointer vc,
int colorval) |
static PIX |
lept.pixAffineGray(PIX pixs,
float[] vc,
byte grayval) |
static PIX |
lept.pixAffineGray(PIX pixs,
FloatBuffer vc,
byte grayval) |
static PIX |
lept.pixAffineGray(PIX pixs,
FloatPointer vc,
byte grayval) |
static PIX |
lept.pixAffinePta(PIX pixs,
PTA ptad,
PTA ptas,
int incolor) |
static PIX |
lept.pixAffinePtaColor(PIX pixs,
PTA ptad,
PTA ptas,
int colorval) |
static PIX |
lept.pixAffinePtaGray(PIX pixs,
PTA ptad,
PTA ptas,
byte grayval) |
static PIX |
lept.pixAffinePtaWithAlpha(PIX pixs,
PTA ptad,
PTA ptas,
PIX pixg,
float fract,
int border) |
static PIX |
lept.pixAffineSampled(PIX pixs,
float[] vc,
int incolor) |
static PIX |
lept.pixAffineSampled(PIX pixs,
FloatBuffer vc,
int incolor) |
static PIX |
lept.pixAffineSampled(PIX pixs,
FloatPointer vc,
int incolor) |
static PIX |
lept.pixAffineSampledPta(PIX pixs,
PTA ptad,
PTA ptas,
int incolor) |
static PIX |
lept.pixAffineSequential(PIX pixs,
PTA ptad,
PTA ptas,
int bw,
int bh) |
static NUMA |
lept.pixaFindAreaFractionMasked(PIXA pixa,
PIX pixm,
int debug) |
static int |
lept.pixaInitFull(PIXA pixa,
PIX pix,
BOX box) |
static int |
lept.pixaInsertPix(PIXA pixa,
int index,
PIX pixs,
BOX box) |
static PIX |
lept.pixAlphaBlendUniform(PIX pixs,
int color) |
static int |
lept.pixAlphaIsOpaque(PIX pix,
int[] popaque) |
static int |
lept.pixAlphaIsOpaque(PIX pix,
IntBuffer popaque) |
static int |
lept.pixAlphaIsOpaque(PIX pix,
IntPointer popaque) |
static PIXA |
lept.pixaMakeFromTiledPix(PIX pixs,
int w,
int h,
int start,
int num,
BOXA boxa) |
static PIXA |
lept.pixaMorphSequenceByRegion(PIX pixs,
PIXA pixam,
BytePointer sequence,
int minw,
int minh) |
static PIXA |
lept.pixaMorphSequenceByRegion(PIX pixs,
PIXA pixam,
String sequence,
int minw,
int minh) |
static PIX |
lept.pixAnd(PIX pixd,
PIX pixs1,
PIX pixs2) |
static PIX |
lept.pixApplyInvBackgroundGrayMap(PIX pixs,
PIX pixm,
int sx,
int sy) |
static PIX |
lept.pixApplyInvBackgroundRGBMap(PIX pixs,
PIX pixmr,
PIX pixmg,
PIX pixmb,
int sx,
int sy) |
static PIX |
lept.pixApplyVariableGrayMap(PIX pixs,
PIX pixg,
int target) |
static PIXA |
lept.pixaRemoveOutliers1(PIXA pixas,
float minscore,
int mintarget,
int minsize,
PIX ppixsave,
PIX ppixrem) |
static PIXA |
lept.pixaRemoveOutliers2(PIXA pixas,
float minscore,
int minsize,
PIX ppixsave,
PIX ppixrem) |
static int |
lept.pixaRemovePixAndSave(PIXA pixa,
int index,
PIX ppix,
BOX pbox) |
static PIX |
lept.pixaRenderComponent(PIX pixs,
PIXA pixa,
int index) |
static int |
lept.pixaReplacePix(PIXA pixa,
int index,
PIX pix,
BOX box) |
static PIXA |
lept.pixaSplitPix(PIX pixs,
int nx,
int ny,
int borderwidth,
int bordercolor) |
static int |
lept.pixAssignToNearestColor(PIX pixd,
PIX pixs,
PIX pixm,
int level,
int[] countarray) |
static int |
lept.pixAssignToNearestColor(PIX pixd,
PIX pixs,
PIX pixm,
int level,
IntBuffer countarray) |
static int |
lept.pixAssignToNearestColor(PIX pixd,
PIX pixs,
PIX pixm,
int level,
IntPointer countarray) |
static PIX |
lept.pixAutoPhotoinvert(PIX pixs,
int thresh,
PIX ppixm,
PIXA pixadb) |
static PIX |
lept.pixAutoPhotoinvert(PIX pixs,
int thresh,
PointerPointer ppixm,
PIXA pixadb) |
static NUMA |
lept.pixAverageByColumn(PIX pix,
BOX box,
int type) |
static NUMA |
lept.pixAverageByRow(PIX pix,
BOX box,
int type) |
static int |
lept.pixAverageInRect(PIX pixs,
PIX pixm,
BOX box,
int minval,
int maxval,
int subsamp,
float[] pave) |
static int |
lept.pixAverageInRect(PIX pixs,
PIX pixm,
BOX box,
int minval,
int maxval,
int subsamp,
FloatBuffer pave) |
static int |
lept.pixAverageInRect(PIX pixs,
PIX pixm,
BOX box,
int minval,
int maxval,
int subsamp,
FloatPointer pave) |
static int |
lept.pixAverageInRectRGB(PIX pixs,
PIX pixm,
BOX box,
int subsamp,
int[] pave) |
static int |
lept.pixAverageInRectRGB(PIX pixs,
PIX pixm,
BOX box,
int subsamp,
IntBuffer pave) |
static int |
lept.pixAverageInRectRGB(PIX pixs,
PIX pixm,
BOX box,
int subsamp,
IntPointer pave) |
static NUMA |
lept.pixAverageIntensityProfile(PIX pixs,
float fract,
int dir,
int first,
int last,
int factor1,
int factor2) |
static float |
lept.pixAverageOnLine(PIX pixs,
int x1,
int y1,
int x2,
int y2,
int factor) |
static PIX |
lept.pixBackgroundNorm(PIX pixs,
PIX pixim,
PIX pixg,
int sx,
int sy,
int thresh,
int mincount,
int bgval,
int smoothx,
int smoothy) |
static PIX |
lept.pixBackgroundNormFlex(PIX pixs,
int sx,
int sy,
int smoothx,
int smoothy,
int delta) |
static int |
lept.pixBackgroundNormGrayArray(PIX pixs,
PIX pixim,
int sx,
int sy,
int thresh,
int mincount,
int bgval,
int smoothx,
int smoothy,
PIX ppixd) |
static int |
lept.pixBackgroundNormGrayArray(PIX pixs,
PIX pixim,
int sx,
int sy,
int thresh,
int mincount,
int bgval,
int smoothx,
int smoothy,
PointerPointer ppixd) |
static int |
lept.pixBackgroundNormGrayArrayMorph(PIX pixs,
PIX pixim,
int reduction,
int size,
int bgval,
PIX ppixd) |
static int |
lept.pixBackgroundNormGrayArrayMorph(PIX pixs,
PIX pixim,
int reduction,
int size,
int bgval,
PointerPointer ppixd) |
static PIX |
lept.pixBackgroundNormMorph(PIX pixs,
PIX pixim,
int reduction,
int size,
int bgval) |
static int |
lept.pixBackgroundNormRGBArrays(PIX pixs,
PIX pixim,
PIX pixg,
int sx,
int sy,
int thresh,
int mincount,
int bgval,
int smoothx,
int smoothy,
PIX ppixr,
PIX ppixg,
PIX ppixb) |
static int |
lept.pixBackgroundNormRGBArrays(PIX pixs,
PIX pixim,
PIX pixg,
int sx,
int sy,
int thresh,
int mincount,
int bgval,
int smoothx,
int smoothy,
PointerPointer ppixr,
PointerPointer ppixg,
PointerPointer ppixb) |
static int |
lept.pixBackgroundNormRGBArraysMorph(PIX pixs,
PIX pixim,
int reduction,
int size,
int bgval,
PIX ppixr,
PIX ppixg,
PIX ppixb) |
static int |
lept.pixBackgroundNormRGBArraysMorph(PIX pixs,
PIX pixim,
int reduction,
int size,
int bgval,
PointerPointer ppixr,
PointerPointer ppixg,
PointerPointer ppixb) |
static PIX |
lept.pixBackgroundNormSimple(PIX pixs,
PIX pixim,
PIX pixg) |
static int |
lept.pixBestCorrelation(PIX pix1,
PIX pix2,
int area1,
int area2,
int etransx,
int etransy,
int maxshift,
int[] tab8,
int[] pdelx,
int[] pdely,
float[] pscore,
int debugflag) |
static int |
lept.pixBestCorrelation(PIX pix1,
PIX pix2,
int area1,
int area2,
int etransx,
int etransy,
int maxshift,
IntBuffer tab8,
IntBuffer pdelx,
IntBuffer pdely,
FloatBuffer pscore,
int debugflag) |
static int |
lept.pixBestCorrelation(PIX pix1,
PIX pix2,
int area1,
int area2,
int etransx,
int etransy,
int maxshift,
IntPointer tab8,
IntPointer pdelx,
IntPointer pdely,
FloatPointer pscore,
int debugflag) |
static PIX |
lept.pixBilateral(PIX pixs,
float spatial_stdev,
float range_stdev,
int ncomps,
int reduction) |
static PIX |
lept.pixBilateralExact(PIX pixs,
L_KERNEL spatial_kel,
L_KERNEL range_kel) |
static PIX |
lept.pixBilateralGray(PIX pixs,
float spatial_stdev,
float range_stdev,
int ncomps,
int reduction) |
static PIX |
lept.pixBilateralGrayExact(PIX pixs,
L_KERNEL spatial_kel,
L_KERNEL range_kel) |
static PIX |
lept.pixBilinear(PIX pixs,
float[] vc,
int incolor) |
static PIX |
lept.pixBilinear(PIX pixs,
FloatBuffer vc,
int incolor) |
static PIX |
lept.pixBilinear(PIX pixs,
FloatPointer vc,
int incolor) |
static PIX |
lept.pixBilinearColor(PIX pixs,
float[] vc,
int colorval) |
static PIX |
lept.pixBilinearColor(PIX pixs,
FloatBuffer vc,
int colorval) |
static PIX |
lept.pixBilinearColor(PIX pixs,
FloatPointer vc,
int colorval) |
static PIX |
lept.pixBilinearGray(PIX pixs,
float[] vc,
byte grayval) |
static PIX |
lept.pixBilinearGray(PIX pixs,
FloatBuffer vc,
byte grayval) |
static PIX |
lept.pixBilinearGray(PIX pixs,
FloatPointer vc,
byte grayval) |
static PIX |
lept.pixBilinearPta(PIX pixs,
PTA ptad,
PTA ptas,
int incolor) |
static PIX |
lept.pixBilinearPtaColor(PIX pixs,
PTA ptad,
PTA ptas,
int colorval) |
static PIX |
lept.pixBilinearPtaGray(PIX pixs,
PTA ptad,
PTA ptas,
byte grayval) |
static PIX |
lept.pixBilinearPtaWithAlpha(PIX pixs,
PTA ptad,
PTA ptas,
PIX pixg,
float fract,
int border) |
static PIX |
lept.pixBilinearSampled(PIX pixs,
float[] vc,
int incolor) |
static PIX |
lept.pixBilinearSampled(PIX pixs,
FloatBuffer vc,
int incolor) |
static PIX |
lept.pixBilinearSampled(PIX pixs,
FloatPointer vc,
int incolor) |
static PIX |
lept.pixBilinearSampledPta(PIX pixs,
PTA ptad,
PTA ptas,
int incolor) |
static PIX |
lept.pixBlend(PIX pixs1,
PIX pixs2,
int x,
int y,
float fract) |
static PIX |
lept.pixBlendBackgroundToColor(PIX pixd,
PIX pixs,
BOX box,
int color,
float gamma,
int minval,
int maxval) |
static PIX |
lept.pixBlendBoxaRandom(PIX pixs,
BOXA boxa,
float fract) |
static int |
lept.pixBlendCmap(PIX pixs,
PIX pixb,
int x,
int y,
int sindex) |
static PIX |
lept.pixBlendColor(PIX pixd,
PIX pixs1,
PIX pixs2,
int x,
int y,
float fract,
int transparent,
int transpix) |
static PIX |
lept.pixBlendColorByChannel(PIX pixd,
PIX pixs1,
PIX pixs2,
int x,
int y,
float rfract,
float gfract,
float bfract,
int transparent,
int transpix) |
static PIX |
lept.pixBlendGray(PIX pixd,
PIX pixs1,
PIX pixs2,
int x,
int y,
float fract,
int type,
int transparent,
int transpix) |
static PIX |
lept.pixBlendGrayAdapt(PIX pixd,
PIX pixs1,
PIX pixs2,
int x,
int y,
float fract,
int shift) |
static PIX |
lept.pixBlendGrayInverse(PIX pixd,
PIX pixs1,
PIX pixs2,
int x,
int y,
float fract) |
static PIX |
lept.pixBlendHardLight(PIX pixd,
PIX pixs1,
PIX pixs2,
int x,
int y,
float fract) |
static int |
lept.pixBlendInRect(PIX pixs,
BOX box,
int val,
float fract) |
static PIX |
lept.pixBlendMask(PIX pixd,
PIX pixs1,
PIX pixs2,
int x,
int y,
float fract,
int type) |
static PIX |
lept.pixBlendWithGrayMask(PIX pixs1,
PIX pixs2,
PIX pixg,
int x,
int y) |
static PIX |
lept.pixBlockBilateralExact(PIX pixs,
float spatial_stdev,
float range_stdev) |
static PIX |
lept.pixBlockconv(PIX pix,
int wc,
int hc) |
static PIX |
lept.pixBlockconvAccum(PIX pixs) |
static PIX |
lept.pixBlockconvGray(PIX pixs,
PIX pixacc,
int wc,
int hc) |
static PIX |
lept.pixBlockconvGrayTile(PIX pixs,
PIX pixacc,
int wc,
int hc) |
static PIX |
lept.pixBlockconvGrayUnnormalized(PIX pixs,
int wc,
int hc) |
static PIX |
lept.pixBlockconvTiled(PIX pix,
int wc,
int hc,
int nx,
int ny) |
static PIX |
lept.pixBlockrank(PIX pixs,
PIX pixacc,
int wc,
int hc,
float rank) |
static PIX |
lept.pixBlocksum(PIX pixs,
PIX pixacc,
int wc,
int hc) |
static PIX |
lept.pixCensusTransform(PIX pixs,
int halfsize,
PIX pixacc) |
static int |
lept.pixCentroid(PIX pix,
int[] centtab,
int[] sumtab,
float[] pxave,
float[] pyave) |
static int |
lept.pixCentroid(PIX pix,
IntBuffer centtab,
IntBuffer sumtab,
FloatBuffer pxave,
FloatBuffer pyave) |
static int |
lept.pixCentroid(PIX pix,
IntPointer centtab,
IntPointer sumtab,
FloatPointer pxave,
FloatPointer pyave) |
static int |
lept.pixCentroid8(PIX pixs,
int factor,
float[] pcx,
float[] pcy) |
static int |
lept.pixCentroid8(PIX pixs,
int factor,
FloatBuffer pcx,
FloatBuffer pcy) |
static int |
lept.pixCentroid8(PIX pixs,
int factor,
FloatPointer pcx,
FloatPointer pcy) |
static int |
lept.pixChangeRefcount(PIX pix,
int delta) |
static int |
lept.pixChooseOutputFormat(PIX pix) |
static PIX |
lept.pixCleanBackgroundToWhite(PIX pixs,
PIX pixim,
PIX pixg,
float gamma,
int blackval,
int whiteval) |
static int |
lept.pixCleanupByteProcessing(PIX pix,
byte[] lineptrs) |
static int |
lept.pixCleanupByteProcessing(PIX pix,
ByteBuffer lineptrs) |
static int |
lept.pixCleanupByteProcessing(PIX pix,
BytePointer lineptrs) |
static int |
lept.pixCleanupByteProcessing(PIX pix,
PointerPointer lineptrs) |
static int |
lept.pixClearAll(PIX pix) |
static int |
lept.pixClearInRect(PIX pix,
BOX box) |
static int |
lept.pixClearPixel(PIX pix,
int x,
int y) |
static int |
lept.pixClipBoxToEdges(PIX pixs,
BOX boxs,
int lowthresh,
int highthresh,
int maxwidth,
int factor,
PIX ppixd,
BOX pboxd) |
static int |
lept.pixClipBoxToEdges(PIX pixs,
BOX boxs,
int lowthresh,
int highthresh,
int maxwidth,
int factor,
PointerPointer ppixd,
PointerPointer pboxd) |
static int |
lept.pixClipBoxToForeground(PIX pixs,
BOX boxs,
PIX ppixd,
BOX pboxd) |
static int |
lept.pixClipBoxToForeground(PIX pixs,
BOX boxs,
PointerPointer ppixd,
PointerPointer pboxd) |
static PIX |
lept.pixClipMasked(PIX pixs,
PIX pixm,
int x,
int y,
int outval) |
static PIX |
lept.pixClipRectangle(PIX pixs,
BOX box,
BOX pboxc) |
static PIX |
lept.pixClipRectangle(PIX pixs,
BOX box,
PointerPointer pboxc) |
static PIXA |
lept.pixClipRectangles(PIX pixs,
BOXA boxa) |
static PIX |
lept.pixClipRectangleWithBorder(PIX pixs,
BOX box,
int maxbord,
BOX pboxn) |
static PIX |
lept.pixClipRectangleWithBorder(PIX pixs,
BOX box,
int maxbord,
PointerPointer pboxn) |
static int |
lept.pixClipToForeground(PIX pixs,
PIX ppixd,
BOX pbox) |
static int |
lept.pixClipToForeground(PIX pixs,
PointerPointer ppixd,
PointerPointer pbox) |
static PIX |
lept.pixClone(PIX pixs) |
static PIX |
lept.pixClose(PIX pixd,
PIX pixs,
SEL sel) |
static PIX |
lept.pixCloseBrick(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixCloseBrickDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixCloseCompBrick(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixCloseCompBrickDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixCloseCompBrickExtendDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixCloseGeneralized(PIX pixd,
PIX pixs,
SEL sel) |
static PIX |
lept.pixCloseGray(PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixCloseGray3(PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixCloseSafe(PIX pixd,
PIX pixs,
SEL sel) |
static PIX |
lept.pixCloseSafeBrick(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixCloseSafeCompBrick(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static int |
lept.pixcmapIsValid(PIXCMAP cmap,
PIX pix,
int[] pvalid) |
static int |
lept.pixcmapIsValid(PIXCMAP cmap,
PIX pix,
IntBuffer pvalid) |
static int |
lept.pixcmapIsValid(PIXCMAP cmap,
PIX pix,
IntPointer pvalid) |
static int |
lept.pixColorContent(PIX pixs,
int rref,
int gref,
int bref,
int mingray,
PIX ppixr,
PIX ppixg,
PIX ppixb) |
static int |
lept.pixColorContent(PIX pixs,
int rref,
int gref,
int bref,
int mingray,
PointerPointer ppixr,
PointerPointer ppixg,
PointerPointer ppixb) |
static PIX |
lept.pixColorFill(PIX pixs,
int minmax,
int maxdiff,
int smooth,
int minarea,
int debug) |
static int |
lept.pixColorFraction(PIX pixs,
int darkthresh,
int lightthresh,
int diffthresh,
int factor,
float[] ppixfract,
float[] pcolorfract) |
static int |
lept.pixColorFraction(PIX pixs,
int darkthresh,
int lightthresh,
int diffthresh,
int factor,
FloatBuffer ppixfract,
FloatBuffer pcolorfract) |
static int |
lept.pixColorFraction(PIX pixs,
int darkthresh,
int lightthresh,
int diffthresh,
int factor,
FloatPointer ppixfract,
FloatPointer pcolorfract) |
static int |
lept.pixColorGray(PIX pixs,
BOX box,
int type,
int thresh,
int rval,
int gval,
int bval) |
static int |
lept.pixColorGrayCmap(PIX pixs,
BOX box,
int type,
int rval,
int gval,
int bval) |
static PIX |
lept.pixColorGrayMasked(PIX pixs,
PIX pixm,
int type,
int thresh,
int rval,
int gval,
int bval) |
static int |
lept.pixColorGrayMaskedCmap(PIX pixs,
PIX pixm,
int type,
int rval,
int gval,
int bval) |
static PIX |
lept.pixColorGrayRegions(PIX pixs,
BOXA boxa,
int type,
int thresh,
int rval,
int gval,
int bval) |
static int |
lept.pixColorGrayRegionsCmap(PIX pixs,
BOXA boxa,
int type,
int rval,
int gval,
int bval) |
static PIX |
lept.pixColorizeGray(PIX pixs,
int color,
int cmapflag) |
static PIX |
lept.pixColorMagnitude(PIX pixs,
int rref,
int gref,
int bref,
int type) |
static PIX |
lept.pixColorMorph(PIX pixs,
int type,
int hsize,
int vsize) |
static PIX |
lept.pixColorMorphSequence(PIX pixs,
BytePointer sequence,
int dispsep,
int dispy) |
static PIX |
lept.pixColorMorphSequence(PIX pixs,
String sequence,
int dispsep,
int dispy) |
static PIX |
lept.pixColorSegment(PIX pixs,
int maxdist,
int maxcolors,
int selsize,
int finalcolors,
int debugflag) |
static int |
lept.pixColorSegmentClean(PIX pixs,
int selsize,
int[] countarray) |
static int |
lept.pixColorSegmentClean(PIX pixs,
int selsize,
IntBuffer countarray) |
static int |
lept.pixColorSegmentClean(PIX pixs,
int selsize,
IntPointer countarray) |
static PIX |
lept.pixColorSegmentCluster(PIX pixs,
int maxdist,
int maxcolors,
int debugflag) |
static int |
lept.pixColorSegmentRemoveColors(PIX pixd,
PIX pixs,
int finalcolors) |
static int |
lept.pixColorsForQuantization(PIX pixs,
int thresh,
int[] pncolors,
int[] piscolor,
int debug) |
static int |
lept.pixColorsForQuantization(PIX pixs,
int thresh,
IntBuffer pncolors,
IntBuffer piscolor,
int debug) |
static int |
lept.pixColorsForQuantization(PIX pixs,
int thresh,
IntPointer pncolors,
IntPointer piscolor,
int debug) |
static PIX |
lept.pixColorShiftRGB(PIX pixs,
float rfract,
float gfract,
float bfract) |
static PIX |
lept.pixColorShiftWhitePoint(PIX pixs,
int rref,
int gref,
int bref) |
static int |
lept.pixColumnStats(PIX pixs,
BOX box,
NUMA pnamean,
NUMA pnamedian,
NUMA pnamode,
NUMA pnamodecount,
NUMA pnavar,
NUMA pnarootvar) |
static int |
lept.pixColumnStats(PIX pixs,
BOX box,
PointerPointer pnamean,
PointerPointer pnamedian,
PointerPointer pnamode,
PointerPointer pnamodecount,
PointerPointer pnavar,
PointerPointer pnarootvar) |
static int |
lept.pixCombineMasked(PIX pixd,
PIX pixs,
PIX pixm) |
static int |
lept.pixCombineMaskedGeneral(PIX pixd,
PIX pixs,
PIX pixm,
int x,
int y) |
static int |
lept.pixCompareBinary(PIX pix1,
PIX pix2,
int comptype,
float[] pfract,
PIX ppixdiff) |
static int |
lept.pixCompareBinary(PIX pix1,
PIX pix2,
int comptype,
FloatBuffer pfract,
PIX ppixdiff) |
static int |
lept.pixCompareBinary(PIX pix1,
PIX pix2,
int comptype,
FloatPointer pfract,
PIX ppixdiff) |
static int |
lept.pixCompareBinary(PIX pix1,
PIX pix2,
int comptype,
FloatPointer pfract,
PointerPointer ppixdiff) |
static int |
lept.pixCompareGray(PIX pix1,
PIX pix2,
int comptype,
int plottype,
int[] psame,
float[] pdiff,
float[] prmsdiff,
PIX ppixdiff) |
static int |
lept.pixCompareGray(PIX pix1,
PIX pix2,
int comptype,
int plottype,
IntBuffer psame,
FloatBuffer pdiff,
FloatBuffer prmsdiff,
PIX ppixdiff) |
static int |
lept.pixCompareGray(PIX pix1,
PIX pix2,
int comptype,
int plottype,
IntPointer psame,
FloatPointer pdiff,
FloatPointer prmsdiff,
PIX ppixdiff) |
static int |
lept.pixCompareGray(PIX pix1,
PIX pix2,
int comptype,
int plottype,
IntPointer psame,
FloatPointer pdiff,
FloatPointer prmsdiff,
PointerPointer ppixdiff) |
static int |
lept.pixCompareGrayByHisto(PIX pix1,
PIX pix2,
BOX box1,
BOX box2,
float minratio,
int maxgray,
int factor,
int n,
float[] pscore,
int debugflag) |
static int |
lept.pixCompareGrayByHisto(PIX pix1,
PIX pix2,
BOX box1,
BOX box2,
float minratio,
int maxgray,
int factor,
int n,
FloatBuffer pscore,
int debugflag) |
static int |
lept.pixCompareGrayByHisto(PIX pix1,
PIX pix2,
BOX box1,
BOX box2,
float minratio,
int maxgray,
int factor,
int n,
FloatPointer pscore,
int debugflag) |
static int |
lept.pixCompareGrayOrRGB(PIX pix1,
PIX pix2,
int comptype,
int plottype,
int[] psame,
float[] pdiff,
float[] prmsdiff,
PIX ppixdiff) |
static int |
lept.pixCompareGrayOrRGB(PIX pix1,
PIX pix2,
int comptype,
int plottype,
IntBuffer psame,
FloatBuffer pdiff,
FloatBuffer prmsdiff,
PIX ppixdiff) |
static int |
lept.pixCompareGrayOrRGB(PIX pix1,
PIX pix2,
int comptype,
int plottype,
IntPointer psame,
FloatPointer pdiff,
FloatPointer prmsdiff,
PIX ppixdiff) |
static int |
lept.pixCompareGrayOrRGB(PIX pix1,
PIX pix2,
int comptype,
int plottype,
IntPointer psame,
FloatPointer pdiff,
FloatPointer prmsdiff,
PointerPointer ppixdiff) |
static int |
lept.pixComparePhotoRegionsByHisto(PIX pix1,
PIX pix2,
BOX box1,
BOX box2,
float minratio,
int factor,
int n,
float[] pscore,
int debugflag) |
static int |
lept.pixComparePhotoRegionsByHisto(PIX pix1,
PIX pix2,
BOX box1,
BOX box2,
float minratio,
int factor,
int n,
FloatBuffer pscore,
int debugflag) |
static int |
lept.pixComparePhotoRegionsByHisto(PIX pix1,
PIX pix2,
BOX box1,
BOX box2,
float minratio,
int factor,
int n,
FloatPointer pscore,
int debugflag) |
static NUMA |
lept.pixCompareRankDifference(PIX pix1,
PIX pix2,
int factor) |
static int |
lept.pixCompareRGB(PIX pix1,
PIX pix2,
int comptype,
int plottype,
int[] psame,
float[] pdiff,
float[] prmsdiff,
PIX ppixdiff) |
static int |
lept.pixCompareRGB(PIX pix1,
PIX pix2,
int comptype,
int plottype,
IntBuffer psame,
FloatBuffer pdiff,
FloatBuffer prmsdiff,
PIX ppixdiff) |
static int |
lept.pixCompareRGB(PIX pix1,
PIX pix2,
int comptype,
int plottype,
IntPointer psame,
FloatPointer pdiff,
FloatPointer prmsdiff,
PIX ppixdiff) |
static int |
lept.pixCompareRGB(PIX pix1,
PIX pix2,
int comptype,
int plottype,
IntPointer psame,
FloatPointer pdiff,
FloatPointer prmsdiff,
PointerPointer ppixdiff) |
static int |
lept.pixCompareTiled(PIX pix1,
PIX pix2,
int sx,
int sy,
int type,
PIX ppixdiff) |
static int |
lept.pixCompareTiled(PIX pix1,
PIX pix2,
int sx,
int sy,
int type,
PointerPointer ppixdiff) |
static int |
lept.pixCompareWithTranslation(PIX pix1,
PIX pix2,
int thresh,
int[] pdelx,
int[] pdely,
float[] pscore,
int debugflag) |
static int |
lept.pixCompareWithTranslation(PIX pix1,
PIX pix2,
int thresh,
IntBuffer pdelx,
IntBuffer pdely,
FloatBuffer pscore,
int debugflag) |
static int |
lept.pixCompareWithTranslation(PIX pix1,
PIX pix2,
int thresh,
IntPointer pdelx,
IntPointer pdely,
FloatPointer pscore,
int debugflag) |
static PIXC |
lept.pixcompCreateFromPix(PIX pix,
int comptype) |
static FPIX |
lept.pixComponentFunction(PIX pix,
float rnum,
float gnum,
float bnum,
float rdenom,
float gdenom,
float bdenom) |
static int |
lept.pixConformsToRectangle(PIX pixs,
BOX box,
int dist,
int[] pconforms) |
static int |
lept.pixConformsToRectangle(PIX pixs,
BOX box,
int dist,
IntBuffer pconforms) |
static int |
lept.pixConformsToRectangle(PIX pixs,
BOX box,
int dist,
IntPointer pconforms) |
static BOXA |
lept.pixConnComp(PIX pixs,
PIXA ppixa,
int connectivity) |
static BOXA |
lept.pixConnComp(PIX pixs,
PointerPointer ppixa,
int connectivity) |
static PIX |
lept.pixConnCompAreaTransform(PIX pixs,
int connect) |
static BOXA |
lept.pixConnCompBB(PIX pixs,
int connectivity) |
static int |
lept.pixConnCompIncrAdd(PIX pixs,
PTAA ptaa,
int[] pncc,
float x,
float y,
int debug) |
static int |
lept.pixConnCompIncrAdd(PIX pixs,
PTAA ptaa,
IntBuffer pncc,
float x,
float y,
int debug) |
static int |
lept.pixConnCompIncrAdd(PIX pixs,
PTAA ptaa,
IntPointer pncc,
float x,
float y,
int debug) |
static int |
lept.pixConnCompIncrInit(PIX pixs,
int conn,
PIX ppixd,
PTAA pptaa,
int[] pncc) |
static int |
lept.pixConnCompIncrInit(PIX pixs,
int conn,
PIX ppixd,
PTAA pptaa,
IntBuffer pncc) |
static int |
lept.pixConnCompIncrInit(PIX pixs,
int conn,
PIX ppixd,
PTAA pptaa,
IntPointer pncc) |
static int |
lept.pixConnCompIncrInit(PIX pixs,
int conn,
PointerPointer ppixd,
PointerPointer pptaa,
IntPointer pncc) |
static BOXA |
lept.pixConnCompPixa(PIX pixs,
PIXA ppixa,
int connectivity) |
static BOXA |
lept.pixConnCompPixa(PIX pixs,
PointerPointer ppixa,
int connectivity) |
static PIX |
lept.pixConnCompTransform(PIX pixs,
int connect,
int depth) |
static PIX |
lept.pixContrastNorm(PIX pixd,
PIX pixs,
int sx,
int sy,
int mindiff,
int smoothx,
int smoothy) |
static PIX |
lept.pixContrastTRC(PIX pixd,
PIX pixs,
float factor) |
static PIX |
lept.pixContrastTRCMasked(PIX pixd,
PIX pixs,
PIX pixm,
float factor) |
static PIX |
lept.pixConvert16To8(PIX pixs,
int type) |
static PIX |
lept.pixConvert1To16(PIX pixd,
PIX pixs,
short val0,
short val1) |
static PIX |
lept.pixConvert1To2(PIX pixd,
PIX pixs,
int val0,
int val1) |
static PIX |
lept.pixConvert1To2Cmap(PIX pixs) |
static PIX |
lept.pixConvert1To32(PIX pixd,
PIX pixs,
int val0,
int val1) |
static PIX |
lept.pixConvert1To4(PIX pixd,
PIX pixs,
int val0,
int val1) |
static PIX |
lept.pixConvert1To4Cmap(PIX pixs) |
static PIX |
lept.pixConvert1To8(PIX pixd,
PIX pixs,
byte val0,
byte val1) |
static PIX |
lept.pixConvert1To8Cmap(PIX pixs) |
static PIX |
lept.pixConvert24To32(PIX pixs) |
static PIX |
lept.pixConvert2To8(PIX pixs,
byte val0,
byte val1,
byte val2,
byte val3,
int cmapflag) |
static PIX |
lept.pixConvert32To16(PIX pixs,
int type) |
static PIX |
lept.pixConvert32To24(PIX pixs) |
static PIX |
lept.pixConvert32To8(PIX pixs,
int type16,
int type8) |
static PIX |
lept.pixConvert4To8(PIX pixs,
int cmapflag) |
static PIX |
lept.pixConvert8To16(PIX pixs,
int leftshift) |
static PIX |
lept.pixConvert8To2(PIX pix) |
static PIX |
lept.pixConvert8To32(PIX pixs) |
static PIX |
lept.pixConvert8To4(PIX pix) |
static PIX |
lept.pixConvertCmapTo1(PIX pixs) |
static PIX |
lept.pixConvertColorToSubpixelRGB(PIX pixs,
float scalex,
float scaley,
int order) |
static L_DNA |
lept.pixConvertDataToDna(PIX pix) |
static PIX |
lept.pixConvertForPSWrap(PIX pixs) |
static PIX |
lept.pixConvertGrayToColormap(PIX pixs) |
static PIX |
lept.pixConvertGrayToColormap8(PIX pixs,
int mindepth) |
static PIX |
lept.pixConvertGrayToFalseColor(PIX pixs,
float gamma) |
static PIX |
lept.pixConvertGrayToSubpixelRGB(PIX pixs,
float scalex,
float scaley,
int order) |
static PIX |
lept.pixConvertHSVToRGB(PIX pixd,
PIX pixs) |
static PIX |
lept.pixConvertLossless(PIX pixs,
int d) |
static PIX |
lept.pixConvertRGBToBinaryArb(PIX pixs,
float rc,
float gc,
float bc,
int thresh,
int relation) |
static PIX |
lept.pixConvertRGBToCmapLossless(PIX pixs) |
static PIX |
lept.pixConvertRGBToColormap(PIX pixs,
int ditherflag) |
static PIX |
lept.pixConvertRGBToGray(PIX pixs,
float rwt,
float gwt,
float bwt) |
static PIX |
lept.pixConvertRGBToGrayArb(PIX pixs,
float rc,
float gc,
float bc) |
static PIX |
lept.pixConvertRGBToGrayFast(PIX pixs) |
static PIX |
lept.pixConvertRGBToGrayGeneral(PIX pixs,
int type,
float rwt,
float gwt,
float bwt) |
static PIX |
lept.pixConvertRGBToGrayMinMax(PIX pixs,
int type) |
static PIX |
lept.pixConvertRGBToGraySatBoost(PIX pixs,
int refval) |
static PIX |
lept.pixConvertRGBToHSV(PIX pixd,
PIX pixs) |
static PIX |
lept.pixConvertRGBToHue(PIX pixs) |
static FPIXA |
lept.pixConvertRGBToLAB(PIX pixs) |
static PIX |
lept.pixConvertRGBToLuminance(PIX pixs) |
static PIX |
lept.pixConvertRGBToSaturation(PIX pixs) |
static PIX |
lept.pixConvertRGBToValue(PIX pixs) |
static FPIXA |
lept.pixConvertRGBToXYZ(PIX pixs) |
static PIX |
lept.pixConvertRGBToYUV(PIX pixd,
PIX pixs) |
static PIX |
lept.pixConvertTo1(PIX pixs,
int threshold) |
static PIX |
lept.pixConvertTo16(PIX pixs) |
static PIX |
lept.pixConvertTo1Adaptive(PIX pixs) |
static PIX |
lept.pixConvertTo1BySampling(PIX pixs,
int factor,
int threshold) |
static PIX |
lept.pixConvertTo2(PIX pixs) |
static PIX |
lept.pixConvertTo32(PIX pixs) |
static PIX |
lept.pixConvertTo32BySampling(PIX pixs,
int factor) |
static PIX |
lept.pixConvertTo4(PIX pixs) |
static PIX |
lept.pixConvertTo8(PIX pixs,
int cmapflag) |
static PIX |
lept.pixConvertTo8BySampling(PIX pixs,
int factor,
int cmapflag) |
static PIX |
lept.pixConvertTo8Colormap(PIX pixs,
int dither) |
static PIX |
lept.pixConvertTo8Or32(PIX pixs,
int copyflag,
int warnflag) |
static DPIX |
lept.pixConvertToDPix(PIX pixs,
int ncomps) |
static FPIX |
lept.pixConvertToFPix(PIX pixs,
int ncomps) |
static int |
lept.pixConvertToPdf(PIX pix,
int type,
int quality,
BytePointer fileout,
int x,
int y,
int res,
BytePointer title,
L_PDF_DATA plpd,
int _position) |
static int |
lept.pixConvertToPdf(PIX pix,
int type,
int quality,
BytePointer fileout,
int x,
int y,
int res,
BytePointer title,
PointerPointer plpd,
int _position) |
static int |
lept.pixConvertToPdf(PIX pix,
int type,
int quality,
String fileout,
int x,
int y,
int res,
String title,
L_PDF_DATA plpd,
int _position) |
static int |
lept.pixConvertToPdfData(PIX pix,
int type,
int quality,
byte[] pdata,
SizeTPointer pnbytes,
int x,
int y,
int res,
BytePointer title,
L_PDF_DATA plpd,
int _position) |
static int |
lept.pixConvertToPdfData(PIX pix,
int type,
int quality,
byte[] pdata,
SizeTPointer pnbytes,
int x,
int y,
int res,
String title,
L_PDF_DATA plpd,
int _position) |
static int |
lept.pixConvertToPdfData(PIX pix,
int type,
int quality,
ByteBuffer pdata,
SizeTPointer pnbytes,
int x,
int y,
int res,
BytePointer title,
L_PDF_DATA plpd,
int _position) |
static int |
lept.pixConvertToPdfData(PIX pix,
int type,
int quality,
ByteBuffer pdata,
SizeTPointer pnbytes,
int x,
int y,
int res,
String title,
L_PDF_DATA plpd,
int _position) |
static int |
lept.pixConvertToPdfData(PIX pix,
int type,
int quality,
BytePointer pdata,
SizeTPointer pnbytes,
int x,
int y,
int res,
BytePointer title,
L_PDF_DATA plpd,
int _position) |
static int |
lept.pixConvertToPdfData(PIX pix,
int type,
int quality,
BytePointer pdata,
SizeTPointer pnbytes,
int x,
int y,
int res,
String title,
L_PDF_DATA plpd,
int _position) |
static int |
lept.pixConvertToPdfData(PIX pix,
int type,
int quality,
PointerPointer pdata,
SizeTPointer pnbytes,
int x,
int y,
int res,
BytePointer title,
PointerPointer plpd,
int _position) |
static int |
lept.pixConvertToPdfDataSegmented(PIX pixs,
int res,
int type,
int thresh,
BOXA boxa,
int quality,
float scalefactor,
BytePointer title,
byte[] pdata,
SizeTPointer pnbytes) |
static int |
lept.pixConvertToPdfDataSegmented(PIX pixs,
int res,
int type,
int thresh,
BOXA boxa,
int quality,
float scalefactor,
BytePointer title,
ByteBuffer pdata,
SizeTPointer pnbytes) |
static int |
lept.pixConvertToPdfDataSegmented(PIX pixs,
int res,
int type,
int thresh,
BOXA boxa,
int quality,
float scalefactor,
BytePointer title,
BytePointer pdata,
SizeTPointer pnbytes) |
static int |
lept.pixConvertToPdfDataSegmented(PIX pixs,
int res,
int type,
int thresh,
BOXA boxa,
int quality,
float scalefactor,
BytePointer title,
PointerPointer pdata,
SizeTPointer pnbytes) |
static int |
lept.pixConvertToPdfDataSegmented(PIX pixs,
int res,
int type,
int thresh,
BOXA boxa,
int quality,
float scalefactor,
String title,
byte[] pdata,
SizeTPointer pnbytes) |
static int |
lept.pixConvertToPdfDataSegmented(PIX pixs,
int res,
int type,
int thresh,
BOXA boxa,
int quality,
float scalefactor,
String title,
ByteBuffer pdata,
SizeTPointer pnbytes) |
static int |
lept.pixConvertToPdfDataSegmented(PIX pixs,
int res,
int type,
int thresh,
BOXA boxa,
int quality,
float scalefactor,
String title,
BytePointer pdata,
SizeTPointer pnbytes) |
static int |
lept.pixConvertToPdfSegmented(PIX pixs,
int res,
int type,
int thresh,
BOXA boxa,
int quality,
float scalefactor,
BytePointer title,
BytePointer fileout) |
static int |
lept.pixConvertToPdfSegmented(PIX pixs,
int res,
int type,
int thresh,
BOXA boxa,
int quality,
float scalefactor,
String title,
String fileout) |
static PIX |
lept.pixConvertToSubpixelRGB(PIX pixs,
float scalex,
float scaley,
int order) |
static PIX |
lept.pixConvertYUVToRGB(PIX pixd,
PIX pixs) |
static PIX |
lept.pixConvolve(PIX pixs,
L_KERNEL kel,
int outdepth,
int normflag) |
static PIX |
lept.pixConvolveRGB(PIX pixs,
L_KERNEL kel) |
static PIX |
lept.pixConvolveRGBSep(PIX pixs,
L_KERNEL kelx,
L_KERNEL kely) |
static PIX |
lept.pixConvolveSep(PIX pixs,
L_KERNEL kelx,
L_KERNEL kely,
int outdepth,
int normflag) |
static PIX |
lept.pixConvolveWithBias(PIX pixs,
L_KERNEL kel1,
L_KERNEL kel2,
int force8,
int[] pbias) |
static PIX |
lept.pixConvolveWithBias(PIX pixs,
L_KERNEL kel1,
L_KERNEL kel2,
int force8,
IntBuffer pbias) |
static PIX |
lept.pixConvolveWithBias(PIX pixs,
L_KERNEL kel1,
L_KERNEL kel2,
int force8,
IntPointer pbias) |
static PIX |
lept.pixCopy(PIX pixd,
PIX pixs) |
static PIX |
lept.pixCopyBorder(PIX pixd,
PIX pixs,
int left,
int right,
int top,
int bot) |
static int |
lept.pixCopyColormap(PIX pixd,
PIX pixs) |
static int |
lept.pixCopyDimensions(PIX pixd,
PIX pixs) |
static int |
lept.pixCopyInputFormat(PIX pixd,
PIX pixs) |
static int |
lept.pixCopyResolution(PIX pixd,
PIX pixs) |
static int |
lept.pixCopyRGBComponent(PIX pixd,
PIX pixs,
int comp) |
static int |
lept.pixCopySpp(PIX pixd,
PIX pixs) |
static int |
lept.pixCopyText(PIX pixd,
PIX pixs) |
static PIX |
lept.pixCopyWithBoxa(PIX pixs,
BOXA boxa,
int background) |
static int |
lept.pixCorrelationBinary(PIX pix1,
PIX pix2,
float[] pval) |
static int |
lept.pixCorrelationBinary(PIX pix1,
PIX pix2,
FloatBuffer pval) |
static int |
lept.pixCorrelationBinary(PIX pix1,
PIX pix2,
FloatPointer pval) |
static int |
lept.pixCorrelationScore(PIX pix1,
PIX pix2,
int area1,
int area2,
float delx,
float dely,
int maxdiffw,
int maxdiffh,
int[] tab,
float[] pscore) |
static int |
lept.pixCorrelationScore(PIX pix1,
PIX pix2,
int area1,
int area2,
float delx,
float dely,
int maxdiffw,
int maxdiffh,
IntBuffer tab,
FloatBuffer pscore) |
static int |
lept.pixCorrelationScore(PIX pix1,
PIX pix2,
int area1,
int area2,
float delx,
float dely,
int maxdiffw,
int maxdiffh,
IntPointer tab,
FloatPointer pscore) |
static int |
lept.pixCorrelationScoreShifted(PIX pix1,
PIX pix2,
int area1,
int area2,
int delx,
int dely,
int[] tab,
float[] pscore) |
static int |
lept.pixCorrelationScoreShifted(PIX pix1,
PIX pix2,
int area1,
int area2,
int delx,
int dely,
IntBuffer tab,
FloatBuffer pscore) |
static int |
lept.pixCorrelationScoreShifted(PIX pix1,
PIX pix2,
int area1,
int area2,
int delx,
int dely,
IntPointer tab,
FloatPointer pscore) |
static int |
lept.pixCorrelationScoreSimple(PIX pix1,
PIX pix2,
int area1,
int area2,
float delx,
float dely,
int maxdiffw,
int maxdiffh,
int[] tab,
float[] pscore) |
static int |
lept.pixCorrelationScoreSimple(PIX pix1,
PIX pix2,
int area1,
int area2,
float delx,
float dely,
int maxdiffw,
int maxdiffh,
IntBuffer tab,
FloatBuffer pscore) |
static int |
lept.pixCorrelationScoreSimple(PIX pix1,
PIX pix2,
int area1,
int area2,
float delx,
float dely,
int maxdiffw,
int maxdiffh,
IntPointer tab,
FloatPointer pscore) |
static int |
lept.pixCorrelationScoreThresholded(PIX pix1,
PIX pix2,
int area1,
int area2,
float delx,
float dely,
int maxdiffw,
int maxdiffh,
int[] tab,
int[] downcount,
float score_threshold) |
static int |
lept.pixCorrelationScoreThresholded(PIX pix1,
PIX pix2,
int area1,
int area2,
float delx,
float dely,
int maxdiffw,
int maxdiffh,
IntBuffer tab,
IntBuffer downcount,
float score_threshold) |
static int |
lept.pixCorrelationScoreThresholded(PIX pix1,
PIX pix2,
int area1,
int area2,
float delx,
float dely,
int maxdiffw,
int maxdiffh,
IntPointer tab,
IntPointer downcount,
float score_threshold) |
static int |
lept.pixCountArbInRect(PIX pixs,
BOX box,
int val,
int factor,
int[] pcount) |
static int |
lept.pixCountArbInRect(PIX pixs,
BOX box,
int val,
int factor,
IntBuffer pcount) |
static int |
lept.pixCountArbInRect(PIX pixs,
BOX box,
int val,
int factor,
IntPointer pcount) |
static NUMA |
lept.pixCountByColumn(PIX pix,
BOX box) |
static NUMA |
lept.pixCountByRow(PIX pix,
BOX box) |
static int |
lept.pixCountConnComp(PIX pixs,
int connectivity,
int[] pcount) |
static int |
lept.pixCountConnComp(PIX pixs,
int connectivity,
IntBuffer pcount) |
static int |
lept.pixCountConnComp(PIX pixs,
int connectivity,
IntPointer pcount) |
static int |
lept.pixCountPixels(PIX pixs,
int[] pcount,
int[] tab8) |
static int |
lept.pixCountPixels(PIX pixs,
IntBuffer pcount,
IntBuffer tab8) |
static int |
lept.pixCountPixels(PIX pixs,
IntPointer pcount,
IntPointer tab8) |
static NUMA |
lept.pixCountPixelsByColumn(PIX pix) |
static NUMA |
lept.pixCountPixelsByRow(PIX pix,
int[] tab8) |
static NUMA |
lept.pixCountPixelsByRow(PIX pix,
IntBuffer tab8) |
static NUMA |
lept.pixCountPixelsByRow(PIX pix,
IntPointer tab8) |
static int |
lept.pixCountPixelsInRect(PIX pixs,
BOX box,
int[] pcount,
int[] tab8) |
static int |
lept.pixCountPixelsInRect(PIX pixs,
BOX box,
IntBuffer pcount,
IntBuffer tab8) |
static int |
lept.pixCountPixelsInRect(PIX pixs,
BOX box,
IntPointer pcount,
IntPointer tab8) |
static int |
lept.pixCountPixelsInRow(PIX pix,
int row,
int[] pcount,
int[] tab8) |
static int |
lept.pixCountPixelsInRow(PIX pix,
int row,
IntBuffer pcount,
IntBuffer tab8) |
static int |
lept.pixCountPixelsInRow(PIX pix,
int row,
IntPointer pcount,
IntPointer tab8) |
static int |
lept.pixCountRGBColors(PIX pixs,
int factor,
int[] pncolors) |
static int |
lept.pixCountRGBColors(PIX pixs,
int factor,
IntBuffer pncolors) |
static int |
lept.pixCountRGBColors(PIX pixs,
int factor,
IntPointer pncolors) |
static int |
lept.pixCountRGBColorsByHash(PIX pixs,
int[] pncolors) |
static int |
lept.pixCountRGBColorsByHash(PIX pixs,
IntBuffer pncolors) |
static int |
lept.pixCountRGBColorsByHash(PIX pixs,
IntPointer pncolors) |
static int |
lept.pixCountTextColumns(PIX pixs,
float deltafract,
float peakfract,
float clipfract,
int[] pncols,
PIXA pixadb) |
static int |
lept.pixCountTextColumns(PIX pixs,
float deltafract,
float peakfract,
float clipfract,
IntBuffer pncols,
PIXA pixadb) |
static int |
lept.pixCountTextColumns(PIX pixs,
float deltafract,
float peakfract,
float clipfract,
IntPointer pncols,
PIXA pixadb) |
static PIX |
lept.pixCreateRGBImage(PIX pixr,
PIX pixg,
PIX pixb) |
static PIX |
lept.pixCreateTemplate(PIX pixs) |
static PIX |
lept.pixCreateTemplateNoInit(PIX pixs) |
static int |
lept.pixCropAlignedToCentroid(PIX pix1,
PIX pix2,
int factor,
BOX pbox1,
BOX pbox2) |
static int |
lept.pixCropAlignedToCentroid(PIX pix1,
PIX pix2,
int factor,
PointerPointer pbox1,
PointerPointer pbox2) |
static int |
lept.pixCropToMatch(PIX pixs1,
PIX pixs2,
PIX ppixd1,
PIX ppixd2) |
static int |
lept.pixCropToMatch(PIX pixs1,
PIX pixs2,
PointerPointer ppixd1,
PointerPointer ppixd2) |
static PIX |
lept.pixCropToSize(PIX pixs,
int w,
int h) |
static PIX |
lept.pixDarkenGray(PIX pixd,
PIX pixs,
int thresh,
int satlimit) |
static int |
lept.pixDecideIfPhotoImage(PIX pix,
int factor,
float thresh,
int n,
NUMAA pnaa,
PIXA pixadebug) |
static int |
lept.pixDecideIfPhotoImage(PIX pix,
int factor,
float thresh,
int n,
PointerPointer pnaa,
PIXA pixadebug) |
static int |
lept.pixDecideIfTable(PIX pixs,
BOX box,
int orient,
int[] pscore,
PIXA pixadb) |
static int |
lept.pixDecideIfTable(PIX pixs,
BOX box,
int orient,
IntBuffer pscore,
PIXA pixadb) |
static int |
lept.pixDecideIfTable(PIX pixs,
BOX box,
int orient,
IntPointer pscore,
PIXA pixadb) |
static int |
lept.pixDecideIfText(PIX pixs,
BOX box,
int[] pistext,
PIXA pixadb) |
static int |
lept.pixDecideIfText(PIX pixs,
BOX box,
IntBuffer pistext,
PIXA pixadb) |
static int |
lept.pixDecideIfText(PIX pixs,
BOX box,
IntPointer pistext,
PIXA pixadb) |
static PIX |
lept.pixDeskew(PIX pixs,
int redsearch) |
static PIX |
lept.pixDeskewBarcode(PIX pixs,
PIX pixb,
BOX box,
int margin,
int threshold,
float[] pangle,
float[] pconf) |
static PIX |
lept.pixDeskewBarcode(PIX pixs,
PIX pixb,
BOX box,
int margin,
int threshold,
FloatBuffer pangle,
FloatBuffer pconf) |
static PIX |
lept.pixDeskewBarcode(PIX pixs,
PIX pixb,
BOX box,
int margin,
int threshold,
FloatPointer pangle,
FloatPointer pconf) |
static PIX |
lept.pixDeskewBoth(PIX pixs,
int redsearch) |
static PIX |
lept.pixDeskewGeneral(PIX pixs,
int redsweep,
float sweeprange,
float sweepdelta,
int redsearch,
int thresh,
float[] pangle,
float[] pconf) |
static PIX |
lept.pixDeskewGeneral(PIX pixs,
int redsweep,
float sweeprange,
float sweepdelta,
int redsearch,
int thresh,
FloatBuffer pangle,
FloatBuffer pconf) |
static PIX |
lept.pixDeskewGeneral(PIX pixs,
int redsweep,
float sweeprange,
float sweepdelta,
int redsearch,
int thresh,
FloatPointer pangle,
FloatPointer pconf) |
static PIX |
lept.pixDeskewLocal(PIX pixs,
int nslices,
int redsweep,
int redsearch,
float sweeprange,
float sweepdelta,
float minbsdelta) |
static void |
lept.pixDestroy(PIX ppix) |
static int |
lept.pixDestroyColormap(PIX pix) |
static PIX |
lept.pixDilate(PIX pixd,
PIX pixs,
SEL sel) |
static PIX |
lept.pixDilateBrick(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixDilateBrickDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixDilateCompBrick(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixDilateCompBrickDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixDilateCompBrickExtendDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixDilateGray(PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixDilateGray3(PIX pixs,
int hsize,
int vsize) |
static int |
lept.pixDisplay(PIX pixs,
int x,
int y) |
static PIX |
lept.pixDisplayDiffBinary(PIX pix1,
PIX pix2) |
static PIX |
lept.pixDisplayHitMissSel(PIX pixs,
SEL sel,
int scalefactor,
int hitcolor,
int misscolor) |
static PIX |
lept.pixDisplayLayersRGBA(PIX pixs,
int val,
int maxw) |
static PIX |
lept.pixDisplayMatchedPattern(PIX pixs,
PIX pixp,
PIX pixe,
int x0,
int y0,
int color,
float scale,
int nlevels) |
static PIX |
lept.pixDisplayPta(PIX pixd,
PIX pixs,
PTA pta) |
static PIX |
lept.pixDisplayPtaa(PIX pixs,
PTAA ptaa) |
static PIX |
lept.pixDisplayPtaaPattern(PIX pixd,
PIX pixs,
PTAA ptaa,
PIX pixp,
int cx,
int cy) |
static PIX |
lept.pixDisplayPtaPattern(PIX pixd,
PIX pixs,
PTA pta,
PIX pixp,
int cx,
int cy,
int color) |
static PIX |
lept.pixDisplaySelectedPixels(PIX pixs,
PIX pixm,
SEL sel,
int val) |
static int |
lept.pixDisplayWithTitle(PIX pixs,
int x,
int y,
BytePointer title,
int dispflag) |
static int |
lept.pixDisplayWithTitle(PIX pixs,
int x,
int y,
String title,
int dispflag) |
static int |
lept.pixDisplayWrite(PIX pixs,
int reduction) |
static PIX |
lept.pixDistanceFunction(PIX pixs,
int connectivity,
int outdepth,
int boundcond) |
static PIX |
lept.pixDitherTo2bpp(PIX pixs,
int cmapflag) |
static PIX |
lept.pixDitherTo2bppSpec(PIX pixs,
int lowerclip,
int upperclip,
int cmapflag) |
static PIX |
lept.pixDitherToBinary(PIX pixs) |
static PIX |
lept.pixDitherToBinarySpec(PIX pixs,
int lowerclip,
int upperclip) |
static PIX |
lept.pixDrawBoxa(PIX pixs,
BOXA boxa,
int width,
int val) |
static PIX |
lept.pixDrawBoxaRandom(PIX pixs,
BOXA boxa,
int width) |
static PIX |
lept.pixEmbedForRotation(PIX pixs,
float angle,
int incolor,
int width,
int height) |
static int |
lept.pixEndianByteSwap(PIX pixs) |
static PIX |
lept.pixEndianByteSwapNew(PIX pixs) |
static int |
lept.pixEndianTwoByteSwap(PIX pixs) |
static PIX |
lept.pixEndianTwoByteSwapNew(PIX pixs) |
static int |
lept.pixEqual(PIX pix1,
PIX pix2,
int[] psame) |
static int |
lept.pixEqual(PIX pix1,
PIX pix2,
IntBuffer psame) |
static int |
lept.pixEqual(PIX pix1,
PIX pix2,
IntPointer psame) |
static PIX |
lept.pixEqualizeTRC(PIX pixd,
PIX pixs,
float fract,
int factor) |
static int |
lept.pixEqualWithAlpha(PIX pix1,
PIX pix2,
int use_alpha,
int[] psame) |
static int |
lept.pixEqualWithAlpha(PIX pix1,
PIX pix2,
int use_alpha,
IntBuffer psame) |
static int |
lept.pixEqualWithAlpha(PIX pix1,
PIX pix2,
int use_alpha,
IntPointer psame) |
static int |
lept.pixEqualWithCmap(PIX pix1,
PIX pix2,
int[] psame) |
static int |
lept.pixEqualWithCmap(PIX pix1,
PIX pix2,
IntBuffer psame) |
static int |
lept.pixEqualWithCmap(PIX pix1,
PIX pix2,
IntPointer psame) |
static PIX |
lept.pixErode(PIX pixd,
PIX pixs,
SEL sel) |
static PIX |
lept.pixErodeBrick(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixErodeBrickDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixErodeCompBrick(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixErodeCompBrickDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixErodeCompBrickExtendDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixErodeGray(PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixErodeGray3(PIX pixs,
int hsize,
int vsize) |
static int |
lept.pixEstimateBackground(PIX pixs,
int darkthresh,
float edgecrop,
int[] pbg) |
static int |
lept.pixEstimateBackground(PIX pixs,
int darkthresh,
float edgecrop,
IntBuffer pbg) |
static int |
lept.pixEstimateBackground(PIX pixs,
int darkthresh,
float edgecrop,
IntPointer pbg) |
static PIX |
lept.pixExpandBinaryPower2(PIX pixs,
int factor) |
static PIX |
lept.pixExpandBinaryReplicate(PIX pixs,
int xfact,
int yfact) |
static PIX |
lept.pixExpandReplicate(PIX pixs,
int factor) |
static PIX |
lept.pixExtendByReplication(PIX pixs,
int addw,
int addh) |
static NUMA |
lept.pixExtractBarcodeCrossings(PIX pixs,
float thresh,
int debugflag) |
static PIXA |
lept.pixExtractBarcodes(PIX pixs,
int debugflag) |
static NUMA |
lept.pixExtractBarcodeWidths1(PIX pixs,
float thresh,
float binfract,
NUMA pnaehist,
NUMA pnaohist,
int debugflag) |
static NUMA |
lept.pixExtractBarcodeWidths1(PIX pixs,
float thresh,
float binfract,
PointerPointer pnaehist,
PointerPointer pnaohist,
int debugflag) |
static NUMA |
lept.pixExtractBarcodeWidths2(PIX pixs,
float thresh,
float[] pwidth,
NUMA pnac,
int debugflag) |
static NUMA |
lept.pixExtractBarcodeWidths2(PIX pixs,
float thresh,
FloatBuffer pwidth,
NUMA pnac,
int debugflag) |
static NUMA |
lept.pixExtractBarcodeWidths2(PIX pixs,
float thresh,
FloatPointer pwidth,
NUMA pnac,
int debugflag) |
static NUMA |
lept.pixExtractBarcodeWidths2(PIX pixs,
float thresh,
FloatPointer pwidth,
PointerPointer pnac,
int debugflag) |
static PIX |
lept.pixExtractBorderConnComps(PIX pixs,
int connectivity) |
static PIX |
lept.pixExtractBoundary(PIX pixs,
int type) |
static IntPointer |
lept.pixExtractData(PIX pixs) |
static NUMA |
lept.pixExtractOnLine(PIX pixs,
int x1,
int y1,
int x2,
int y2,
int factor) |
static PIXA |
lept.pixExtractRawTextlines(PIX pixs,
int maxw,
int maxh,
int adjw,
int adjh,
PIXA pixadb) |
static PIXA |
lept.pixExtractTextlines(PIX pixs,
int maxw,
int maxh,
int minw,
int minh,
int adjw,
int adjh,
PIXA pixadb) |
static PIX |
lept.pixFadeWithGray(PIX pixs,
PIX pixb,
float factor,
int type) |
static PIX |
lept.pixFastTophat(PIX pixs,
int xsize,
int ysize,
int type) |
static PIX |
lept.pixFewColorsMedianCutQuantMixed(PIX pixs,
int ncolor,
int ngray,
int maxncolors,
int darkthresh,
int lightthresh,
int diffthresh) |
static PIX |
lept.pixFewColorsOctcubeQuant1(PIX pixs,
int level) |
static PIX |
lept.pixFewColorsOctcubeQuant2(PIX pixs,
int level,
NUMA na,
int ncolors,
int[] pnerrors) |
static PIX |
lept.pixFewColorsOctcubeQuant2(PIX pixs,
int level,
NUMA na,
int ncolors,
IntBuffer pnerrors) |
static PIX |
lept.pixFewColorsOctcubeQuant2(PIX pixs,
int level,
NUMA na,
int ncolors,
IntPointer pnerrors) |
static PIX |
lept.pixFewColorsOctcubeQuantMixed(PIX pixs,
int level,
int darkthresh,
int lightthresh,
int diffthresh,
float minfract,
int maxspan) |
static PIX |
lept.pixFHMTGen_1(PIX pixd,
PIX pixs,
BytePointer selname) |
static PIX |
lept.pixFHMTGen_1(PIX pixd,
PIX pixs,
String selname) |
static PIX |
lept.pixFillBgFromBorder(PIX pixs,
int connectivity) |
static PIX |
lept.pixFillClosedBorders(PIX pixs,
int connectivity) |
static PIX |
lept.pixFillHolesToBoundingRect(PIX pixs,
int minsize,
float maxhfract,
float minfgfract) |
static int |
lept.pixFillMapHoles(PIX pix,
int nx,
int ny,
int filltype) |
static PIX |
lept.pixFillPolygon(PIX pixs,
PTA pta,
int xmin,
int ymin) |
static PIX |
lept.pixFilterComponentBySize(PIX pixs,
int rankorder,
int type,
int connectivity,
BOX pbox) |
static PIX |
lept.pixFilterComponentBySize(PIX pixs,
int rankorder,
int type,
int connectivity,
PointerPointer pbox) |
static PIX |
lept.pixFinalAccumulate(PIX pixs,
int offset,
int depth) |
static PIX |
lept.pixFinalAccumulateThreshold(PIX pixs,
int offset,
int threshold) |
static int |
lept.pixFindAreaFraction(PIX pixs,
int[] tab,
float[] pfract) |
static int |
lept.pixFindAreaFraction(PIX pixs,
IntBuffer tab,
FloatBuffer pfract) |
static int |
lept.pixFindAreaFraction(PIX pixs,
IntPointer tab,
FloatPointer pfract) |
static int |
lept.pixFindAreaFractionMasked(PIX pixs,
BOX box,
PIX pixm,
int[] tab,
float[] pfract) |
static int |
lept.pixFindAreaFractionMasked(PIX pixs,
BOX box,
PIX pixm,
IntBuffer tab,
FloatBuffer pfract) |
static int |
lept.pixFindAreaFractionMasked(PIX pixs,
BOX box,
PIX pixm,
IntPointer tab,
FloatPointer pfract) |
static int |
lept.pixFindAreaPerimRatio(PIX pixs,
int[] tab,
float[] pfract) |
static int |
lept.pixFindAreaPerimRatio(PIX pixs,
IntBuffer tab,
FloatBuffer pfract) |
static int |
lept.pixFindAreaPerimRatio(PIX pixs,
IntPointer tab,
FloatPointer pfract) |
static NUMA |
lept.pixFindBaselines(PIX pixs,
PointerPointer ppta,
PIXA pixadb) |
static NUMA |
lept.pixFindBaselines(PIX pixs,
PTA ppta,
PIXA pixadb) |
static int |
lept.pixFindCheckerboardCorners(PIX pixs,
int size,
int dilation,
int nsels,
PIX ppix_corners,
PTA ppta_corners,
PIXA pixadb) |
static int |
lept.pixFindCheckerboardCorners(PIX pixs,
int size,
int dilation,
int nsels,
PointerPointer ppix_corners,
PointerPointer ppta_corners,
PIXA pixadb) |
static int |
lept.pixFindColorRegions(PIX pixs,
PIX pixm,
int factor,
int lightthresh,
int darkthresh,
int mindiff,
int colordiff,
float edgefract,
float[] pcolorfract,
PIX pcolormask1,
PIX pcolormask2,
PIXA pixadb) |
static int |
lept.pixFindColorRegions(PIX pixs,
PIX pixm,
int factor,
int lightthresh,
int darkthresh,
int mindiff,
int colordiff,
float edgefract,
FloatBuffer pcolorfract,
PIX pcolormask1,
PIX pcolormask2,
PIXA pixadb) |
static int |
lept.pixFindColorRegions(PIX pixs,
PIX pixm,
int factor,
int lightthresh,
int darkthresh,
int mindiff,
int colordiff,
float edgefract,
FloatPointer pcolorfract,
PIX pcolormask1,
PIX pcolormask2,
PIXA pixadb) |
static int |
lept.pixFindColorRegions(PIX pixs,
PIX pixm,
int factor,
int lightthresh,
int darkthresh,
int mindiff,
int colordiff,
float edgefract,
FloatPointer pcolorfract,
PointerPointer pcolormask1,
PointerPointer pcolormask2,
PIXA pixadb) |
static PTA |
lept.pixFindCornerPixels(PIX pixs) |
static int |
lept.pixFindDifferentialSquareSum(PIX pixs,
float[] psum) |
static int |
lept.pixFindDifferentialSquareSum(PIX pixs,
FloatBuffer psum) |
static int |
lept.pixFindDifferentialSquareSum(PIX pixs,
FloatPointer psum) |
static PIX |
lept.pixFindEqualValues(PIX pixs1,
PIX pixs2) |
static int |
lept.pixFindHistoPeaksHSV(PIX pixs,
int type,
int width,
int height,
int npeaks,
float erasefactor,
PointerPointer ppta,
PointerPointer pnatot,
PointerPointer ppixa) |
static int |
lept.pixFindHistoPeaksHSV(PIX pixs,
int type,
int width,
int height,
int npeaks,
float erasefactor,
PTA ppta,
NUMA pnatot,
PIXA ppixa) |
static int |
lept.pixFindHorizontalRuns(PIX pix,
int y,
int[] xstart,
int[] xend,
int[] pn) |
static int |
lept.pixFindHorizontalRuns(PIX pix,
int y,
IntBuffer xstart,
IntBuffer xend,
IntBuffer pn) |
static int |
lept.pixFindHorizontalRuns(PIX pix,
int y,
IntPointer xstart,
IntPointer xend,
IntPointer pn) |
static int |
lept.pixFindLargeRectangles(PIX pixs,
int polarity,
int nrect,
BOXA pboxa,
PIX ppixdb) |
static int |
lept.pixFindLargeRectangles(PIX pixs,
int polarity,
int nrect,
PointerPointer pboxa,
PointerPointer ppixdb) |
static int |
lept.pixFindLargestRectangle(PIX pixs,
int polarity,
BOX pbox,
PIX ppixdb) |
static int |
lept.pixFindLargestRectangle(PIX pixs,
int polarity,
PointerPointer pbox,
PointerPointer ppixdb) |
static int |
lept.pixFindMaxHorizontalRunOnLine(PIX pix,
int y,
int[] pxstart,
int[] psize) |
static int |
lept.pixFindMaxHorizontalRunOnLine(PIX pix,
int y,
IntBuffer pxstart,
IntBuffer psize) |
static int |
lept.pixFindMaxHorizontalRunOnLine(PIX pix,
int y,
IntPointer pxstart,
IntPointer psize) |
static NUMA |
lept.pixFindMaxRuns(PIX pix,
int direction,
NUMA pnastart) |
static NUMA |
lept.pixFindMaxRuns(PIX pix,
int direction,
PointerPointer pnastart) |
static int |
lept.pixFindMaxVerticalRunOnLine(PIX pix,
int x,
int[] pystart,
int[] psize) |
static int |
lept.pixFindMaxVerticalRunOnLine(PIX pix,
int x,
IntBuffer pystart,
IntBuffer psize) |
static int |
lept.pixFindMaxVerticalRunOnLine(PIX pix,
int x,
IntPointer pystart,
IntPointer psize) |
static int |
lept.pixFindNormalizedSquareSum(PIX pixs,
float[] phratio,
float[] pvratio,
float[] pfract) |
static int |
lept.pixFindNormalizedSquareSum(PIX pixs,
FloatBuffer phratio,
FloatBuffer pvratio,
FloatBuffer pfract) |
static int |
lept.pixFindNormalizedSquareSum(PIX pixs,
FloatPointer phratio,
FloatPointer pvratio,
FloatPointer pfract) |
static int |
lept.pixFindOverlapFraction(PIX pixs1,
PIX pixs2,
int x2,
int y2,
int[] tab,
float[] pratio,
int[] pnoverlap) |
static int |
lept.pixFindOverlapFraction(PIX pixs1,
PIX pixs2,
int x2,
int y2,
IntBuffer tab,
FloatBuffer pratio,
IntBuffer pnoverlap) |
static int |
lept.pixFindOverlapFraction(PIX pixs1,
PIX pixs2,
int x2,
int y2,
IntPointer tab,
FloatPointer pratio,
IntPointer pnoverlap) |
static BOX |
lept.pixFindPageForeground(PIX pixs,
int threshold,
int mindist,
int erasedist,
int showmorph,
PIXAC pixac) |
static int |
lept.pixFindPerimSizeRatio(PIX pixs,
int[] tab,
float[] pratio) |
static int |
lept.pixFindPerimSizeRatio(PIX pixs,
IntBuffer tab,
FloatBuffer pratio) |
static int |
lept.pixFindPerimSizeRatio(PIX pixs,
IntPointer tab,
FloatPointer pratio) |
static int |
lept.pixFindPerimToAreaRatio(PIX pixs,
int[] tab,
float[] pfract) |
static int |
lept.pixFindPerimToAreaRatio(PIX pixs,
IntBuffer tab,
FloatBuffer pfract) |
static int |
lept.pixFindPerimToAreaRatio(PIX pixs,
IntPointer tab,
FloatPointer pfract) |
static BOXA |
lept.pixFindRectangleComps(PIX pixs,
int dist,
int minw,
int minh) |
static BOX |
lept.pixFindRectangleInCC(PIX pixs,
BOX boxs,
float fract,
int dir,
int select,
int debug) |
static int |
lept.pixFindRepCloseTile(PIX pixs,
BOX box,
int searchdir,
int mindist,
int tsize,
int ntiles,
BOX pboxtile,
int debug) |
static int |
lept.pixFindRepCloseTile(PIX pixs,
BOX box,
int searchdir,
int mindist,
int tsize,
int ntiles,
PointerPointer pboxtile,
int debug) |
static int |
lept.pixFindSkew(PIX pixs,
float[] pangle,
float[] pconf) |
static int |
lept.pixFindSkew(PIX pixs,
FloatBuffer pangle,
FloatBuffer pconf) |
static int |
lept.pixFindSkew(PIX pixs,
FloatPointer pangle,
FloatPointer pconf) |
static PIX |
lept.pixFindSkewAndDeskew(PIX pixs,
int redsearch,
float[] pangle,
float[] pconf) |
static PIX |
lept.pixFindSkewAndDeskew(PIX pixs,
int redsearch,
FloatBuffer pangle,
FloatBuffer pconf) |
static PIX |
lept.pixFindSkewAndDeskew(PIX pixs,
int redsearch,
FloatPointer pangle,
FloatPointer pconf) |
static int |
lept.pixFindSkewOrthogonalRange(PIX pixs,
float[] pangle,
float[] pconf,
int redsweep,
int redsearch,
float sweeprange,
float sweepdelta,
float minbsdelta,
float confprior) |
static int |
lept.pixFindSkewOrthogonalRange(PIX pixs,
FloatBuffer pangle,
FloatBuffer pconf,
int redsweep,
int redsearch,
float sweeprange,
float sweepdelta,
float minbsdelta,
float confprior) |
static int |
lept.pixFindSkewOrthogonalRange(PIX pixs,
FloatPointer pangle,
FloatPointer pconf,
int redsweep,
int redsearch,
float sweeprange,
float sweepdelta,
float minbsdelta,
float confprior) |
static int |
lept.pixFindSkewSweep(PIX pixs,
float[] pangle,
int reduction,
float sweeprange,
float sweepdelta) |
static int |
lept.pixFindSkewSweep(PIX pixs,
FloatBuffer pangle,
int reduction,
float sweeprange,
float sweepdelta) |
static int |
lept.pixFindSkewSweep(PIX pixs,
FloatPointer pangle,
int reduction,
float sweeprange,
float sweepdelta) |
static int |
lept.pixFindSkewSweepAndSearch(PIX pixs,
float[] pangle,
float[] pconf,
int redsweep,
int redsearch,
float sweeprange,
float sweepdelta,
float minbsdelta) |
static int |
lept.pixFindSkewSweepAndSearch(PIX pixs,
FloatBuffer pangle,
FloatBuffer pconf,
int redsweep,
int redsearch,
float sweeprange,
float sweepdelta,
float minbsdelta) |
static int |
lept.pixFindSkewSweepAndSearch(PIX pixs,
FloatPointer pangle,
FloatPointer pconf,
int redsweep,
int redsearch,
float sweeprange,
float sweepdelta,
float minbsdelta) |
static int |
lept.pixFindSkewSweepAndSearchScore(PIX pixs,
float[] pangle,
float[] pconf,
float[] pendscore,
int redsweep,
int redsearch,
float sweepcenter,
float sweeprange,
float sweepdelta,
float minbsdelta) |
static int |
lept.pixFindSkewSweepAndSearchScore(PIX pixs,
FloatBuffer pangle,
FloatBuffer pconf,
FloatBuffer pendscore,
int redsweep,
int redsearch,
float sweepcenter,
float sweeprange,
float sweepdelta,
float minbsdelta) |
static int |
lept.pixFindSkewSweepAndSearchScore(PIX pixs,
FloatPointer pangle,
FloatPointer pconf,
FloatPointer pendscore,
int redsweep,
int redsearch,
float sweepcenter,
float sweeprange,
float sweepdelta,
float minbsdelta) |
static int |
lept.pixFindSkewSweepAndSearchScorePivot(PIX pixs,
float[] pangle,
float[] pconf,
float[] pendscore,
int redsweep,
int redsearch,
float sweepcenter,
float sweeprange,
float sweepdelta,
float minbsdelta,
int pivot) |
static int |
lept.pixFindSkewSweepAndSearchScorePivot(PIX pixs,
FloatBuffer pangle,
FloatBuffer pconf,
FloatBuffer pendscore,
int redsweep,
int redsearch,
float sweepcenter,
float sweeprange,
float sweepdelta,
float minbsdelta,
int pivot) |
static int |
lept.pixFindSkewSweepAndSearchScorePivot(PIX pixs,
FloatPointer pangle,
FloatPointer pconf,
FloatPointer pendscore,
int redsweep,
int redsearch,
float sweepcenter,
float sweeprange,
float sweepdelta,
float minbsdelta,
int pivot) |
static int |
lept.pixFindStrokeLength(PIX pixs,
int[] tab8,
int[] plength) |
static int |
lept.pixFindStrokeLength(PIX pixs,
IntBuffer tab8,
IntBuffer plength) |
static int |
lept.pixFindStrokeLength(PIX pixs,
IntPointer tab8,
IntPointer plength) |
static int |
lept.pixFindStrokeWidth(PIX pixs,
float thresh,
int[] tab8,
float[] pwidth,
NUMA pnahisto) |
static int |
lept.pixFindStrokeWidth(PIX pixs,
float thresh,
IntBuffer tab8,
FloatBuffer pwidth,
NUMA pnahisto) |
static int |
lept.pixFindStrokeWidth(PIX pixs,
float thresh,
IntPointer tab8,
FloatPointer pwidth,
NUMA pnahisto) |
static int |
lept.pixFindStrokeWidth(PIX pixs,
float thresh,
IntPointer tab8,
FloatPointer pwidth,
PointerPointer pnahisto) |
static int |
lept.pixFindThreshFgExtent(PIX pixs,
int thresh,
int[] ptop,
int[] pbot) |
static int |
lept.pixFindThreshFgExtent(PIX pixs,
int thresh,
IntBuffer ptop,
IntBuffer pbot) |
static int |
lept.pixFindThreshFgExtent(PIX pixs,
int thresh,
IntPointer ptop,
IntPointer pbot) |
static int |
lept.pixFindVerticalRuns(PIX pix,
int x,
int[] ystart,
int[] yend,
int[] pn) |
static int |
lept.pixFindVerticalRuns(PIX pix,
int x,
IntBuffer ystart,
IntBuffer yend,
IntBuffer pn) |
static int |
lept.pixFindVerticalRuns(PIX pix,
int x,
IntPointer ystart,
IntPointer yend,
IntPointer pn) |
static int |
lept.pixFindWordAndCharacterBoxes(PIX pixs,
BOX boxs,
int thresh,
BOXA pboxaw,
BOXAA pboxaac,
BytePointer debugdir) |
static int |
lept.pixFindWordAndCharacterBoxes(PIX pixs,
BOX boxs,
int thresh,
BOXA pboxaw,
BOXAA pboxaac,
String debugdir) |
static int |
lept.pixFindWordAndCharacterBoxes(PIX pixs,
BOX boxs,
int thresh,
PointerPointer pboxaw,
PointerPointer pboxaac,
BytePointer debugdir) |
static PIX |
lept.pixFixedOctcubeQuant256(PIX pixs,
int ditherflag) |
static PIX |
lept.pixFixedOctcubeQuantGenRGB(PIX pixs,
int level) |
static PIX |
lept.pixFlipLR(PIX pixd,
PIX pixs) |
static int |
lept.pixFlipPixel(PIX pix,
int x,
int y) |
static PIX |
lept.pixFlipTB(PIX pixd,
PIX pixs) |
static PIX |
lept.pixFMorphopGen_1(PIX pixd,
PIX pixs,
int operation,
byte[] selname) |
static PIX |
lept.pixFMorphopGen_1(PIX pixd,
PIX pixs,
int operation,
ByteBuffer selname) |
static PIX |
lept.pixFMorphopGen_1(PIX pixd,
PIX pixs,
int operation,
BytePointer selname) |
static PIX |
lept.pixFMorphopGen_2(PIX pixd,
PIX pixs,
int operation,
byte[] selname) |
static PIX |
lept.pixFMorphopGen_2(PIX pixd,
PIX pixs,
int operation,
ByteBuffer selname) |
static PIX |
lept.pixFMorphopGen_2(PIX pixd,
PIX pixs,
int operation,
BytePointer selname) |
static int |
lept.pixForegroundFraction(PIX pix,
float[] pfract) |
static int |
lept.pixForegroundFraction(PIX pix,
FloatBuffer pfract) |
static int |
lept.pixForegroundFraction(PIX pix,
FloatPointer pfract) |
static int |
lept.pixFractionFgInMask(PIX pix1,
PIX pix2,
float[] pfract) |
static int |
lept.pixFractionFgInMask(PIX pix1,
PIX pix2,
FloatBuffer pfract) |
static int |
lept.pixFractionFgInMask(PIX pix1,
PIX pix2,
FloatPointer pfract) |
static int |
lept.pixFreeData(PIX pix) |
static PIX |
lept.pixGammaTRC(PIX pixd,
PIX pixs,
float gamma,
int minval,
int maxval) |
static PIX |
lept.pixGammaTRCMasked(PIX pixd,
PIX pixs,
PIX pixm,
float gamma,
int minval,
int maxval) |
static PIX |
lept.pixGammaTRCWithAlpha(PIX pixd,
PIX pixs,
float gamma,
int minval,
int maxval) |
static int |
lept.pixGenerateCIData(PIX pixs,
int type,
int quality,
int ascii85,
L_COMP_DATA pcid) |
static int |
lept.pixGenerateCIData(PIX pixs,
int type,
int quality,
int ascii85,
PointerPointer pcid) |
static PIX |
lept.pixGenerateHalftoneMask(PIX pixs,
PIX ppixtext,
int[] phtfound,
PIXA pixadb) |
static PIX |
lept.pixGenerateHalftoneMask(PIX pixs,
PIX ppixtext,
IntBuffer phtfound,
PIXA pixadb) |
static PIX |
lept.pixGenerateHalftoneMask(PIX pixs,
PIX ppixtext,
IntPointer phtfound,
PIXA pixadb) |
static PIX |
lept.pixGenerateHalftoneMask(PIX pixs,
PointerPointer ppixtext,
IntPointer phtfound,
PIXA pixadb) |
static PIX |
lept.pixGenerateMaskByBand(PIX pixs,
int lower,
int upper,
int inband,
int usecmap) |
static PIX |
lept.pixGenerateMaskByBand32(PIX pixs,
int refval,
int delm,
int delp,
float fractm,
float fractp) |
static PIX |
lept.pixGenerateMaskByDiscr32(PIX pixs,
int refval1,
int refval2,
int distflag) |
static PIX |
lept.pixGenerateMaskByValue(PIX pixs,
int val,
int usecmap) |
static PTA |
lept.pixGeneratePtaBoundary(PIX pixs,
int width) |
static SEL |
lept.pixGenerateSelBoundary(PIX pixs,
int hitdist,
int missdist,
int hitskip,
int missskip,
int topflag,
int botflag,
int leftflag,
int rightflag,
PIX ppixe) |
static SEL |
lept.pixGenerateSelBoundary(PIX pixs,
int hitdist,
int missdist,
int hitskip,
int missskip,
int topflag,
int botflag,
int leftflag,
int rightflag,
PointerPointer ppixe) |
static SEL |
lept.pixGenerateSelRandom(PIX pixs,
float hitfract,
float missfract,
int distance,
int toppix,
int botpix,
int leftpix,
int rightpix,
PIX ppixe) |
static SEL |
lept.pixGenerateSelRandom(PIX pixs,
float hitfract,
float missfract,
int distance,
int toppix,
int botpix,
int leftpix,
int rightpix,
PointerPointer ppixe) |
static SEL |
lept.pixGenerateSelWithRuns(PIX pixs,
int nhlines,
int nvlines,
int distance,
int minlength,
int toppix,
int botpix,
int leftpix,
int rightpix,
PIX ppixe) |
static SEL |
lept.pixGenerateSelWithRuns(PIX pixs,
int nhlines,
int nvlines,
int distance,
int minlength,
int toppix,
int botpix,
int leftpix,
int rightpix,
PointerPointer ppixe) |
static PIX |
lept.pixGenHalftoneMask(PIX pixs,
PIX ppixtext,
int[] phtfound,
int debug) |
static PIX |
lept.pixGenHalftoneMask(PIX pixs,
PIX ppixtext,
IntBuffer phtfound,
int debug) |
static PIX |
lept.pixGenHalftoneMask(PIX pixs,
PIX ppixtext,
IntPointer phtfound,
int debug) |
static PIX |
lept.pixGenHalftoneMask(PIX pixs,
PointerPointer ppixtext,
IntPointer phtfound,
int debug) |
static int |
lept.pixGenPhotoHistos(PIX pixs,
BOX box,
int factor,
float thresh,
int n,
NUMAA pnaa,
int[] pw,
int[] ph,
int debugindex) |
static int |
lept.pixGenPhotoHistos(PIX pixs,
BOX box,
int factor,
float thresh,
int n,
NUMAA pnaa,
IntBuffer pw,
IntBuffer ph,
int debugindex) |
static int |
lept.pixGenPhotoHistos(PIX pixs,
BOX box,
int factor,
float thresh,
int n,
NUMAA pnaa,
IntPointer pw,
IntPointer ph,
int debugindex) |
static int |
lept.pixGenPhotoHistos(PIX pixs,
BOX box,
int factor,
float thresh,
int n,
PointerPointer pnaa,
IntPointer pw,
IntPointer ph,
int debugindex) |
static PIX |
lept.pixGenTextblockMask(PIX pixs,
PIX pixvws,
PIXA pixadb) |
static PIX |
lept.pixGenTextlineMask(PIX pixs,
PIX ppixvws,
int[] ptlfound,
PIXA pixadb) |
static PIX |
lept.pixGenTextlineMask(PIX pixs,
PIX ppixvws,
IntBuffer ptlfound,
PIXA pixadb) |
static PIX |
lept.pixGenTextlineMask(PIX pixs,
PIX ppixvws,
IntPointer ptlfound,
PIXA pixadb) |
static PIX |
lept.pixGenTextlineMask(PIX pixs,
PointerPointer ppixvws,
IntPointer ptlfound,
PIXA pixadb) |
static CCBORDA |
lept.pixGetAllCCBorders(PIX pixs) |
static int |
lept.pixGetAutoFormat(PIX pix,
int[] pformat) |
static int |
lept.pixGetAutoFormat(PIX pix,
IntBuffer pformat) |
static int |
lept.pixGetAutoFormat(PIX pix,
IntPointer pformat) |
static int |
lept.pixGetAverageMasked(PIX pixs,
PIX pixm,
int x,
int y,
int factor,
int type,
float[] pval) |
static int |
lept.pixGetAverageMasked(PIX pixs,
PIX pixm,
int x,
int y,
int factor,
int type,
FloatBuffer pval) |
static int |
lept.pixGetAverageMasked(PIX pixs,
PIX pixm,
int x,
int y,
int factor,
int type,
FloatPointer pval) |
static int |
lept.pixGetAverageMaskedRGB(PIX pixs,
PIX pixm,
int x,
int y,
int factor,
int type,
float[] prval,
float[] pgval,
float[] pbval) |
static int |
lept.pixGetAverageMaskedRGB(PIX pixs,
PIX pixm,
int x,
int y,
int factor,
int type,
FloatBuffer prval,
FloatBuffer pgval,
FloatBuffer pbval) |
static int |
lept.pixGetAverageMaskedRGB(PIX pixs,
PIX pixm,
int x,
int y,
int factor,
int type,
FloatPointer prval,
FloatPointer pgval,
FloatPointer pbval) |
static PIX |
lept.pixGetAverageTiled(PIX pixs,
int sx,
int sy,
int type) |
static int |
lept.pixGetAverageTiledRGB(PIX pixs,
int sx,
int sy,
int type,
PIX ppixr,
PIX ppixg,
PIX ppixb) |
static int |
lept.pixGetAverageTiledRGB(PIX pixs,
int sx,
int sy,
int type,
PointerPointer ppixr,
PointerPointer ppixg,
PointerPointer ppixb) |
static int |
lept.pixGetBackgroundGrayMap(PIX pixs,
PIX pixim,
int sx,
int sy,
int thresh,
int mincount,
PIX ppixd) |
static int |
lept.pixGetBackgroundGrayMap(PIX pixs,
PIX pixim,
int sx,
int sy,
int thresh,
int mincount,
PointerPointer ppixd) |
static int |
lept.pixGetBackgroundGrayMapMorph(PIX pixs,
PIX pixim,
int reduction,
int size,
PIX ppixm) |
static int |
lept.pixGetBackgroundGrayMapMorph(PIX pixs,
PIX pixim,
int reduction,
int size,
PointerPointer ppixm) |
static int |
lept.pixGetBackgroundRGBMap(PIX pixs,
PIX pixim,
PIX pixg,
int sx,
int sy,
int thresh,
int mincount,
PIX ppixmr,
PIX ppixmg,
PIX ppixmb) |
static int |
lept.pixGetBackgroundRGBMap(PIX pixs,
PIX pixim,
PIX pixg,
int sx,
int sy,
int thresh,
int mincount,
PointerPointer ppixmr,
PointerPointer ppixmg,
PointerPointer ppixmb) |
static int |
lept.pixGetBackgroundRGBMapMorph(PIX pixs,
PIX pixim,
int reduction,
int size,
PIX ppixmr,
PIX ppixmg,
PIX ppixmb) |
static int |
lept.pixGetBackgroundRGBMapMorph(PIX pixs,
PIX pixim,
int reduction,
int size,
PointerPointer ppixmr,
PointerPointer ppixmg,
PointerPointer ppixmb) |
static int |
lept.pixGetBinnedColor(PIX pixs,
PIX pixg,
int factor,
int nbins,
int[] pcarray,
PIXA pixadb) |
static int |
lept.pixGetBinnedColor(PIX pixs,
PIX pixg,
int factor,
int nbins,
IntBuffer pcarray,
PIXA pixadb) |
static int |
lept.pixGetBinnedColor(PIX pixs,
PIX pixg,
int factor,
int nbins,
IntPointer pcarray,
PIXA pixadb) |
static int |
lept.pixGetBinnedColor(PIX pixs,
PIX pixg,
int factor,
int nbins,
PointerPointer pcarray,
PIXA pixadb) |
static int |
lept.pixGetBinnedComponentRange(PIX pixs,
int nbins,
int factor,
int color,
int[] pminval,
int[] pmaxval,
int[] pcarray,
int fontsize) |
static int |
lept.pixGetBinnedComponentRange(PIX pixs,
int nbins,
int factor,
int color,
IntBuffer pminval,
IntBuffer pmaxval,
IntBuffer pcarray,
int fontsize) |
static int |
lept.pixGetBinnedComponentRange(PIX pixs,
int nbins,
int factor,
int color,
IntPointer pminval,
IntPointer pmaxval,
IntPointer pcarray,
int fontsize) |
static int |
lept.pixGetBinnedComponentRange(PIX pixs,
int nbins,
int factor,
int color,
IntPointer pminval,
IntPointer pmaxval,
PointerPointer pcarray,
int fontsize) |
static int |
lept.pixGetBlackOrWhiteVal(PIX pixs,
int op,
int[] pval) |
static int |
lept.pixGetBlackOrWhiteVal(PIX pixs,
int op,
IntBuffer pval) |
static int |
lept.pixGetBlackOrWhiteVal(PIX pixs,
int op,
IntPointer pval) |
static NUMA |
lept.pixGetCmapHistogram(PIX pixs,
int factor) |
static NUMA |
lept.pixGetCmapHistogramInRect(PIX pixs,
BOX box,
int factor) |
static NUMA |
lept.pixGetCmapHistogramMasked(PIX pixs,
PIX pixm,
int x,
int y,
int factor) |
static L_AMAP |
lept.pixGetColorAmapHistogram(PIX pixs,
int factor) |
static int |
lept.pixGetColorHistogram(PIX pixs,
int factor,
NUMA pnar,
NUMA pnag,
NUMA pnab) |
static int |
lept.pixGetColorHistogram(PIX pixs,
int factor,
PointerPointer pnar,
PointerPointer pnag,
PointerPointer pnab) |
static int |
lept.pixGetColorHistogramMasked(PIX pixs,
PIX pixm,
int x,
int y,
int factor,
NUMA pnar,
NUMA pnag,
NUMA pnab) |
static int |
lept.pixGetColorHistogramMasked(PIX pixs,
PIX pixm,
int x,
int y,
int factor,
PointerPointer pnar,
PointerPointer pnag,
PointerPointer pnab) |
static PIXCMAP |
lept.pixGetColormap(PIX pix) |
static int |
lept.pixGetColorNearMaskBoundary(PIX pixs,
PIX pixm,
BOX box,
int dist,
int[] pval,
int debug) |
static int |
lept.pixGetColorNearMaskBoundary(PIX pixs,
PIX pixm,
BOX box,
int dist,
IntBuffer pval,
int debug) |
static int |
lept.pixGetColorNearMaskBoundary(PIX pixs,
PIX pixm,
BOX box,
int dist,
IntPointer pval,
int debug) |
static int |
lept.pixGetColumnStats(PIX pixs,
int type,
int nbins,
int thresh,
float[] rowvect) |
static int |
lept.pixGetColumnStats(PIX pixs,
int type,
int nbins,
int thresh,
FloatBuffer rowvect) |
static int |
lept.pixGetColumnStats(PIX pixs,
int type,
int nbins,
int thresh,
FloatPointer rowvect) |
static IntPointer |
lept.pixGetData(PIX pix) |
static int |
lept.pixGetDepth(PIX pix) |
static NUMA |
lept.pixGetDifferenceHistogram(PIX pix1,
PIX pix2,
int factor) |
static int |
lept.pixGetDifferenceStats(PIX pix1,
PIX pix2,
int factor,
int mindiff,
float[] pfractdiff,
float[] pavediff,
int details) |
static int |
lept.pixGetDifferenceStats(PIX pix1,
PIX pix2,
int factor,
int mindiff,
FloatBuffer pfractdiff,
FloatBuffer pavediff,
int details) |
static int |
lept.pixGetDifferenceStats(PIX pix1,
PIX pix2,
int factor,
int mindiff,
FloatPointer pfractdiff,
FloatPointer pavediff,
int details) |
static int |
lept.pixGetDimensions(PIX pix,
int[] pw,
int[] ph,
int[] pd) |
static int |
lept.pixGetDimensions(PIX pix,
IntBuffer pw,
IntBuffer ph,
IntBuffer pd) |
static int |
lept.pixGetDimensions(PIX pix,
IntPointer pw,
IntPointer ph,
IntPointer pd) |
static NUMA |
lept.pixGetEdgeProfile(PIX pixs,
int side,
BytePointer debugfile) |
static NUMA |
lept.pixGetEdgeProfile(PIX pixs,
int side,
String debugfile) |
static int |
lept.pixGetExtremeValue(PIX pixs,
int factor,
int type,
int[] prval,
int[] pgval,
int[] pbval,
int[] pgrayval) |
static int |
lept.pixGetExtremeValue(PIX pixs,
int factor,
int type,
IntBuffer prval,
IntBuffer pgval,
IntBuffer pbval,
IntBuffer pgrayval) |
static int |
lept.pixGetExtremeValue(PIX pixs,
int factor,
int type,
IntPointer prval,
IntPointer pgval,
IntPointer pbval,
IntPointer pgrayval) |
static NUMA |
lept.pixGetGrayHistogram(PIX pixs,
int factor) |
static NUMA |
lept.pixGetGrayHistogramInRect(PIX pixs,
BOX box,
int factor) |
static NUMA |
lept.pixGetGrayHistogramMasked(PIX pixs,
PIX pixm,
int x,
int y,
int factor) |
static NUMAA |
lept.pixGetGrayHistogramTiled(PIX pixs,
int factor,
int nx,
int ny) |
static int |
lept.pixGetHeight(PIX pix) |
static int |
lept.pixGetInputFormat(PIX pix) |
static PIX |
lept.pixGetInvBackgroundMap(PIX pixs,
int bgval,
int smoothx,
int smoothy) |
static int |
lept.pixGetLastOffPixelInRun(PIX pixs,
int x,
int y,
int direction,
int[] ploc) |
static int |
lept.pixGetLastOffPixelInRun(PIX pixs,
int x,
int y,
int direction,
IntBuffer ploc) |
static int |
lept.pixGetLastOffPixelInRun(PIX pixs,
int x,
int y,
int direction,
IntPointer ploc) |
static int |
lept.pixGetLastOnPixelInRun(PIX pixs,
int x,
int y,
int direction,
int[] ploc) |
static int |
lept.pixGetLastOnPixelInRun(PIX pixs,
int x,
int y,
int direction,
IntBuffer ploc) |
static int |
lept.pixGetLastOnPixelInRun(PIX pixs,
int x,
int y,
int direction,
IntPointer ploc) |
static Pointer |
lept.pixGetLinePtrs(PIX pix,
int[] psize) |
static Pointer |
lept.pixGetLinePtrs(PIX pix,
IntBuffer psize) |
static PointerPointer |
lept.pixGetLinePtrs(PIX pix,
IntPointer psize) |
static NUMA |
lept.pixGetLocalSkewAngles(PIX pixs,
int nslices,
int redsweep,
int redsearch,
float sweeprange,
float sweepdelta,
float minbsdelta,
float[] pa,
float[] pb,
int debug) |
static NUMA |
lept.pixGetLocalSkewAngles(PIX pixs,
int nslices,
int redsweep,
int redsearch,
float sweeprange,
float sweepdelta,
float minbsdelta,
FloatBuffer pa,
FloatBuffer pb,
int debug) |
static NUMA |
lept.pixGetLocalSkewAngles(PIX pixs,
int nslices,
int redsweep,
int redsearch,
float sweeprange,
float sweepdelta,
float minbsdelta,
FloatPointer pa,
FloatPointer pb,
int debug) |
static int |
lept.pixGetLocalSkewTransform(PIX pixs,
int nslices,
int redsweep,
int redsearch,
float sweeprange,
float sweepdelta,
float minbsdelta,
PointerPointer pptas,
PointerPointer pptad) |
static int |
lept.pixGetLocalSkewTransform(PIX pixs,
int nslices,
int redsweep,
int redsearch,
float sweeprange,
float sweepdelta,
float minbsdelta,
PTA pptas,
PTA pptad) |
static int |
lept.pixGetMaxColorIndex(PIX pixs,
int[] pmaxindex) |
static int |
lept.pixGetMaxColorIndex(PIX pixs,
IntBuffer pmaxindex) |
static int |
lept.pixGetMaxColorIndex(PIX pixs,
IntPointer pmaxindex) |
static int |
lept.pixGetMaxValueInRect(PIX pixs,
BOX box,
int[] pmaxval,
int[] pxmax,
int[] pymax) |
static int |
lept.pixGetMaxValueInRect(PIX pixs,
BOX box,
IntBuffer pmaxval,
IntBuffer pxmax,
IntBuffer pymax) |
static int |
lept.pixGetMaxValueInRect(PIX pixs,
BOX box,
IntPointer pmaxval,
IntPointer pxmax,
IntPointer pymax) |
static NUMA |
lept.pixGetMomentByColumn(PIX pix,
int order) |
static int |
lept.pixGetMostPopulatedColors(PIX pixs,
int sigbits,
int factor,
int ncolors,
int[] parray,
PIXCMAP pcmap) |
static int |
lept.pixGetMostPopulatedColors(PIX pixs,
int sigbits,
int factor,
int ncolors,
IntBuffer parray,
PIXCMAP pcmap) |
static int |
lept.pixGetMostPopulatedColors(PIX pixs,
int sigbits,
int factor,
int ncolors,
IntPointer parray,
PIXCMAP pcmap) |
static int |
lept.pixGetMostPopulatedColors(PIX pixs,
int sigbits,
int factor,
int ncolors,
PointerPointer parray,
PointerPointer pcmap) |
static int |
lept.pixGetOuterBorder(CCBORD ccb,
PIX pixs,
BOX box) |
static PTAA |
lept.pixGetOuterBordersPtaa(PIX pixs) |
static int |
lept.pixGetPerceptualDiff(PIX pixs1,
PIX pixs2,
int sampling,
int dilation,
int mindiff,
float[] pfract,
PIX ppixdiff1,
PIX ppixdiff2) |
static int |
lept.pixGetPerceptualDiff(PIX pixs1,
PIX pixs2,
int sampling,
int dilation,
int mindiff,
FloatBuffer pfract,
PIX ppixdiff1,
PIX ppixdiff2) |
static int |
lept.pixGetPerceptualDiff(PIX pixs1,
PIX pixs2,
int sampling,
int dilation,
int mindiff,
FloatPointer pfract,
PIX ppixdiff1,
PIX ppixdiff2) |
static int |
lept.pixGetPerceptualDiff(PIX pixs1,
PIX pixs2,
int sampling,
int dilation,
int mindiff,
FloatPointer pfract,
PointerPointer ppixdiff1,
PointerPointer ppixdiff2) |
static int |
lept.pixGetPixel(PIX pix,
int x,
int y,
int[] pval) |
static int |
lept.pixGetPixel(PIX pix,
int x,
int y,
IntBuffer pval) |
static int |
lept.pixGetPixel(PIX pix,
int x,
int y,
IntPointer pval) |
static int |
lept.pixGetPixelAverage(PIX pixs,
PIX pixm,
int x,
int y,
int factor,
int[] pval) |
static int |
lept.pixGetPixelAverage(PIX pixs,
PIX pixm,
int x,
int y,
int factor,
IntBuffer pval) |
static int |
lept.pixGetPixelAverage(PIX pixs,
PIX pixm,
int x,
int y,
int factor,
IntPointer pval) |
static int |
lept.pixGetPixelStats(PIX pixs,
int factor,
int type,
int[] pvalue) |
static int |
lept.pixGetPixelStats(PIX pixs,
int factor,
int type,
IntBuffer pvalue) |
static int |
lept.pixGetPixelStats(PIX pixs,
int factor,
int type,
IntPointer pvalue) |
static int |
lept.pixGetPSNR(PIX pix1,
PIX pix2,
int factor,
float[] ppsnr) |
static int |
lept.pixGetPSNR(PIX pix1,
PIX pix2,
int factor,
FloatBuffer ppsnr) |
static int |
lept.pixGetPSNR(PIX pix1,
PIX pix2,
int factor,
FloatPointer ppsnr) |
static int |
lept.pixGetRandomPixel(PIX pix,
int[] pval,
int[] px,
int[] py) |
static int |
lept.pixGetRandomPixel(PIX pix,
IntBuffer pval,
IntBuffer px,
IntBuffer py) |
static int |
lept.pixGetRandomPixel(PIX pix,
IntPointer pval,
IntPointer px,
IntPointer py) |
static int |
lept.pixGetRangeValues(PIX pixs,
int factor,
int color,
int[] pminval,
int[] pmaxval) |
static int |
lept.pixGetRangeValues(PIX pixs,
int factor,
int color,
IntBuffer pminval,
IntBuffer pmaxval) |
static int |
lept.pixGetRangeValues(PIX pixs,
int factor,
int color,
IntPointer pminval,
IntPointer pmaxval) |
static int |
lept.pixGetRankColorArray(PIX pixs,
int nbins,
int type,
int factor,
int[] pcarray,
PIXA pixadb,
int fontsize) |
static int |
lept.pixGetRankColorArray(PIX pixs,
int nbins,
int type,
int factor,
IntBuffer pcarray,
PIXA pixadb,
int fontsize) |
static int |
lept.pixGetRankColorArray(PIX pixs,
int nbins,
int type,
int factor,
IntPointer pcarray,
PIXA pixadb,
int fontsize) |
static int |
lept.pixGetRankColorArray(PIX pixs,
int nbins,
int type,
int factor,
PointerPointer pcarray,
PIXA pixadb,
int fontsize) |
static int |
lept.pixGetRankValue(PIX pixs,
int factor,
float rank,
int[] pvalue) |
static int |
lept.pixGetRankValue(PIX pixs,
int factor,
float rank,
IntBuffer pvalue) |
static int |
lept.pixGetRankValue(PIX pixs,
int factor,
float rank,
IntPointer pvalue) |
static int |
lept.pixGetRankValueMasked(PIX pixs,
PIX pixm,
int x,
int y,
int factor,
float rank,
float[] pval,
NUMA pna) |
static int |
lept.pixGetRankValueMasked(PIX pixs,
PIX pixm,
int x,
int y,
int factor,
float rank,
FloatBuffer pval,
NUMA pna) |
static int |
lept.pixGetRankValueMasked(PIX pixs,
PIX pixm,
int x,
int y,
int factor,
float rank,
FloatPointer pval,
NUMA pna) |
static int |
lept.pixGetRankValueMasked(PIX pixs,
PIX pixm,
int x,
int y,
int factor,
float rank,
FloatPointer pval,
PointerPointer pna) |
static int |
lept.pixGetRankValueMaskedRGB(PIX pixs,
PIX pixm,
int x,
int y,
int factor,
float rank,
float[] prval,
float[] pgval,
float[] pbval) |
static int |
lept.pixGetRankValueMaskedRGB(PIX pixs,
PIX pixm,
int x,
int y,
int factor,
float rank,
FloatBuffer prval,
FloatBuffer pgval,
FloatBuffer pbval) |
static int |
lept.pixGetRankValueMaskedRGB(PIX pixs,
PIX pixm,
int x,
int y,
int factor,
float rank,
FloatPointer prval,
FloatPointer pgval,
FloatPointer pbval) |
static int |
lept.pixGetRasterData(PIX pixs,
byte[] pdata,
SizeTPointer pnbytes) |
static int |
lept.pixGetRasterData(PIX pixs,
ByteBuffer pdata,
SizeTPointer pnbytes) |
static int |
lept.pixGetRasterData(PIX pixs,
BytePointer pdata,
SizeTPointer pnbytes) |
static int |
lept.pixGetRasterData(PIX pixs,
PointerPointer pdata,
SizeTPointer pnbytes) |
static int |
lept.pixGetRefcount(PIX pix) |
static int |
lept.pixGetRegionsBinary(PIX pixs,
PIX ppixhm,
PIX ppixtm,
PIX ppixtb,
PIXA pixadb) |
static int |
lept.pixGetRegionsBinary(PIX pixs,
PointerPointer ppixhm,
PointerPointer ppixtm,
PointerPointer ppixtb,
PIXA pixadb) |
static int |
lept.pixGetResolution(PIX pix,
int[] pxres,
int[] pyres) |
static int |
lept.pixGetResolution(PIX pix,
IntBuffer pxres,
IntBuffer pyres) |
static int |
lept.pixGetResolution(PIX pix,
IntPointer pxres,
IntPointer pyres) |
static PIX |
lept.pixGetRGBComponent(PIX pixs,
int comp) |
static PIX |
lept.pixGetRGBComponentCmap(PIX pixs,
int comp) |
static NUMA |
lept.pixGetRGBHistogram(PIX pixs,
int sigbits,
int factor) |
static int |
lept.pixGetRGBLine(PIX pixs,
int row,
byte[] bufr,
byte[] bufg,
byte[] bufb) |
static int |
lept.pixGetRGBLine(PIX pixs,
int row,
ByteBuffer bufr,
ByteBuffer bufg,
ByteBuffer bufb) |
static int |
lept.pixGetRGBLine(PIX pixs,
int row,
BytePointer bufr,
BytePointer bufg,
BytePointer bufb) |
static int |
lept.pixGetRGBPixel(PIX pix,
int x,
int y,
int[] prval,
int[] pgval,
int[] pbval) |
static int |
lept.pixGetRGBPixel(PIX pix,
int x,
int y,
IntBuffer prval,
IntBuffer pgval,
IntBuffer pbval) |
static int |
lept.pixGetRGBPixel(PIX pix,
int x,
int y,
IntPointer prval,
IntPointer pgval,
IntPointer pbval) |
static int |
lept.pixGetRowStats(PIX pixs,
int type,
int nbins,
int thresh,
float[] colvect) |
static int |
lept.pixGetRowStats(PIX pixs,
int type,
int nbins,
int thresh,
FloatBuffer colvect) |
static int |
lept.pixGetRowStats(PIX pixs,
int type,
int nbins,
int thresh,
FloatPointer colvect) |
static NUMA |
lept.pixGetRunCentersOnLine(PIX pixs,
int x,
int y,
int minlength) |
static NUMA |
lept.pixGetRunsOnLine(PIX pixs,
int x1,
int y1,
int x2,
int y2) |
static int |
lept.pixGetSortedNeighborValues(PIX pixs,
int x,
int y,
int conn,
int[] pneigh,
int[] pnvals) |
static int |
lept.pixGetSortedNeighborValues(PIX pixs,
int x,
int y,
int conn,
IntBuffer pneigh,
IntBuffer pnvals) |
static int |
lept.pixGetSortedNeighborValues(PIX pixs,
int x,
int y,
int conn,
IntPointer pneigh,
IntPointer pnvals) |
static int |
lept.pixGetSortedNeighborValues(PIX pixs,
int x,
int y,
int conn,
PointerPointer pneigh,
IntPointer pnvals) |
static int |
lept.pixGetSpp(PIX pix) |
static BytePointer |
lept.pixGetText(PIX pix) |
static BytePointer |
lept.pixGetTextCompNew(PIX pix,
SizeTPointer psize) |
static int |
lept.pixGetTileCount(PIX pix,
int[] pn) |
static int |
lept.pixGetTileCount(PIX pix,
IntBuffer pn) |
static int |
lept.pixGetTileCount(PIX pix,
IntPointer pn) |
static int |
lept.pixGetWidth(PIX pix) |
static int |
lept.pixGetWordBoxesInTextlines(PIX pixs,
int minwidth,
int minheight,
int maxwidth,
int maxheight,
BOXA pboxad,
NUMA pnai) |
static int |
lept.pixGetWordBoxesInTextlines(PIX pixs,
int minwidth,
int minheight,
int maxwidth,
int maxheight,
PointerPointer pboxad,
PointerPointer pnai) |
static int |
lept.pixGetWordsInTextlines(PIX pixs,
int minwidth,
int minheight,
int maxwidth,
int maxheight,
BOXA pboxad,
PIXA ppixad,
NUMA pnai) |
static int |
lept.pixGetWordsInTextlines(PIX pixs,
int minwidth,
int minheight,
int maxwidth,
int maxheight,
PointerPointer pboxad,
PointerPointer ppixad,
PointerPointer pnai) |
static int |
lept.pixGetWpl(PIX pix) |
static int |
lept.pixGetXRes(PIX pix) |
static int |
lept.pixGetYRes(PIX pix) |
static PIX |
lept.pixGlobalNormNoSatRGB(PIX pixd,
PIX pixs,
int rval,
int gval,
int bval,
int factor,
float rank) |
static PIX |
lept.pixGlobalNormRGB(PIX pixd,
PIX pixs,
int rval,
int gval,
int bval,
int mapval) |
static PIX |
lept.pixGrayMorphSequence(PIX pixs,
BytePointer sequence,
int dispsep,
int dispy) |
static PIX |
lept.pixGrayMorphSequence(PIX pixs,
String sequence,
int dispsep,
int dispy) |
static PIX |
lept.pixGrayQuantFromCmap(PIX pixs,
PIXCMAP cmap,
int mindepth) |
static PIX |
lept.pixGrayQuantFromHisto(PIX pixd,
PIX pixs,
PIX pixm,
float minfract,
int maxsize) |
static PIX |
lept.pixHalfEdgeByBandpass(PIX pixs,
int sm1h,
int sm1v,
int sm2h,
int sm2v) |
static int |
lept.pixHasHighlightRed(PIX pixs,
int factor,
float minfract,
float fthresh,
int[] phasred,
float[] pratio,
PIX ppixdb) |
static int |
lept.pixHasHighlightRed(PIX pixs,
int factor,
float minfract,
float fthresh,
IntBuffer phasred,
FloatBuffer pratio,
PIX ppixdb) |
static int |
lept.pixHasHighlightRed(PIX pixs,
int factor,
float minfract,
float fthresh,
IntPointer phasred,
FloatPointer pratio,
PIX ppixdb) |
static int |
lept.pixHasHighlightRed(PIX pixs,
int factor,
float minfract,
float fthresh,
IntPointer phasred,
FloatPointer pratio,
PointerPointer ppixdb) |
static int |
lept.pixHaustest(PIX pix1,
PIX pix2,
PIX pix3,
PIX pix4,
float delx,
float dely,
int maxdiffw,
int maxdiffh) |
static PIX |
lept.pixHDome(PIX pixs,
int height,
int connectivity) |
static PIX |
lept.pixHMT(PIX pixd,
PIX pixs,
SEL sel) |
static PIX |
lept.pixHMTDwa_1(PIX pixd,
PIX pixs,
BytePointer selname) |
static PIX |
lept.pixHMTDwa_1(PIX pixd,
PIX pixs,
String selname) |
static PIX |
lept.pixHolesByFilling(PIX pixs,
int connectivity) |
static PIX |
lept.pixHShear(PIX pixd,
PIX pixs,
int yloc,
float radang,
int incolor) |
static PIX |
lept.pixHShearCenter(PIX pixd,
PIX pixs,
float radang,
int incolor) |
static PIX |
lept.pixHShearCorner(PIX pixd,
PIX pixs,
float radang,
int incolor) |
static int |
lept.pixHShearIP(PIX pixs,
int yloc,
float radang,
int incolor) |
static PIX |
lept.pixHShearLI(PIX pixs,
int yloc,
float radang,
int incolor) |
static int |
lept.pixInferResolution(PIX pix,
float longside,
int[] pres) |
static int |
lept.pixInferResolution(PIX pix,
float longside,
IntBuffer pres) |
static int |
lept.pixInferResolution(PIX pix,
float longside,
IntPointer pres) |
static PIX |
lept.pixIntersectionOfMorphOps(PIX pixs,
SELA sela,
int type) |
static PIX |
lept.pixInvert(PIX pixd,
PIX pixs) |
static int |
lept.pixItalicWords(PIX pixs,
BOXA boxaw,
PIX pixw,
BOXA pboxa,
int debugflag) |
static int |
lept.pixItalicWords(PIX pixs,
BOXA boxaw,
PIX pixw,
PointerPointer pboxa,
int debugflag) |
static int |
lept.pixLinearEdgeFade(PIX pixs,
int dir,
int fadeto,
float distfract,
float maxfade) |
static PIX |
lept.pixLinearMapToTargetColor(PIX pixd,
PIX pixs,
int srcval,
int dstval) |
static int |
lept.pixLocalExtrema(PIX pixs,
int maxmin,
int minmax,
PIX ppixmin,
PIX ppixmax) |
static int |
lept.pixLocalExtrema(PIX pixs,
int maxmin,
int minmax,
PointerPointer ppixmin,
PointerPointer ppixmax) |
static BOXA |
lept.pixLocateBarcodes(PIX pixs,
int thresh,
PIX ppixb,
PIX ppixm) |
static BOXA |
lept.pixLocateBarcodes(PIX pixs,
int thresh,
PointerPointer ppixb,
PointerPointer ppixm) |
static PIX |
lept.pixLocToColorTransform(PIX pixs) |
static PIX |
lept.pixMakeAlphaFromMask(PIX pixs,
int dist,
BOX pbox) |
static PIX |
lept.pixMakeAlphaFromMask(PIX pixs,
int dist,
PointerPointer pbox) |
static PIX |
lept.pixMakeArbMaskFromRGB(PIX pixs,
float rc,
float gc,
float bc,
float thresh) |
static PIX |
lept.pixMakeCoveringOfRectangles(PIX pixs,
int maxiters) |
static PIX |
lept.pixMakeHistoHS(PIX pixs,
int factor,
NUMA pnahue,
NUMA pnasat) |
static PIX |
lept.pixMakeHistoHS(PIX pixs,
int factor,
PointerPointer pnahue,
PointerPointer pnasat) |
static PIX |
lept.pixMakeHistoHV(PIX pixs,
int factor,
NUMA pnahue,
NUMA pnaval) |
static PIX |
lept.pixMakeHistoHV(PIX pixs,
int factor,
PointerPointer pnahue,
PointerPointer pnaval) |
static PIX |
lept.pixMakeHistoSV(PIX pixs,
int factor,
NUMA pnasat,
NUMA pnaval) |
static PIX |
lept.pixMakeHistoSV(PIX pixs,
int factor,
PointerPointer pnasat,
PointerPointer pnaval) |
static PIX |
lept.pixMakeMaskFromLUT(PIX pixs,
int[] tab) |
static PIX |
lept.pixMakeMaskFromLUT(PIX pixs,
IntBuffer tab) |
static PIX |
lept.pixMakeMaskFromLUT(PIX pixs,
IntPointer tab) |
static PIX |
lept.pixMakeMaskFromVal(PIX pixs,
int val) |
static PIX |
lept.pixMakeRangeMaskHS(PIX pixs,
int huecenter,
int huehw,
int satcenter,
int sathw,
int regionflag) |
static PIX |
lept.pixMakeRangeMaskHV(PIX pixs,
int huecenter,
int huehw,
int valcenter,
int valhw,
int regionflag) |
static PIX |
lept.pixMakeRangeMaskSV(PIX pixs,
int satcenter,
int sathw,
int valcenter,
int valhw,
int regionflag) |
static PIX |
lept.pixMapWithInvariantHue(PIX pixd,
PIX pixs,
int srcval,
float fract) |
static PIX |
lept.pixMaskBoxa(PIX pixd,
PIX pixs,
BOXA boxa,
int op) |
static PIX |
lept.pixMaskConnComp(PIX pixs,
int connectivity,
BOXA pboxa) |
static PIX |
lept.pixMaskConnComp(PIX pixs,
int connectivity,
PointerPointer pboxa) |
static PIX |
lept.pixMaskedThreshOnBackgroundNorm(PIX pixs,
PIX pixim,
int sx,
int sy,
int thresh,
int mincount,
int smoothx,
int smoothy,
float scorefract,
int[] pthresh) |
static PIX |
lept.pixMaskedThreshOnBackgroundNorm(PIX pixs,
PIX pixim,
int sx,
int sy,
int thresh,
int mincount,
int smoothx,
int smoothy,
float scorefract,
IntBuffer pthresh) |
static PIX |
lept.pixMaskedThreshOnBackgroundNorm(PIX pixs,
PIX pixim,
int sx,
int sy,
int thresh,
int mincount,
int smoothx,
int smoothy,
float scorefract,
IntPointer pthresh) |
static PIX |
lept.pixMaskOverColorPixels(PIX pixs,
int threshdiff,
int mindist) |
static PIX |
lept.pixMaskOverColorRange(PIX pixs,
int rmin,
int rmax,
int gmin,
int gmax,
int bmin,
int bmax) |
static PIX |
lept.pixMaskOverGrayPixels(PIX pixs,
int maxlimit,
int satlimit) |
static int |
lept.pixMaxAspectRatio(PIX pixs,
float[] pratio) |
static int |
lept.pixMaxAspectRatio(PIX pixs,
FloatBuffer pratio) |
static int |
lept.pixMaxAspectRatio(PIX pixs,
FloatPointer pratio) |
static PIX |
lept.pixMaxDynamicRange(PIX pixs,
int type) |
static PIX |
lept.pixMaxDynamicRangeRGB(PIX pixs,
int type) |
static int |
lept.pixMeanInRectangle(PIX pixs,
BOX box,
PIX pixma,
float[] pval) |
static int |
lept.pixMeanInRectangle(PIX pixs,
BOX box,
PIX pixma,
FloatBuffer pval) |
static int |
lept.pixMeanInRectangle(PIX pixs,
BOX box,
PIX pixma,
FloatPointer pval) |
static DPIX |
lept.pixMeanSquareAccum(PIX pixs) |
static int |
lept.pixMeasureEdgeSmoothness(PIX pixs,
int side,
int minjump,
int minreversal,
float[] pjpl,
float[] pjspl,
float[] prpl,
BytePointer debugfile) |
static int |
lept.pixMeasureEdgeSmoothness(PIX pixs,
int side,
int minjump,
int minreversal,
float[] pjpl,
float[] pjspl,
float[] prpl,
String debugfile) |
static int |
lept.pixMeasureEdgeSmoothness(PIX pixs,
int side,
int minjump,
int minreversal,
FloatBuffer pjpl,
FloatBuffer pjspl,
FloatBuffer prpl,
BytePointer debugfile) |
static int |
lept.pixMeasureEdgeSmoothness(PIX pixs,
int side,
int minjump,
int minreversal,
FloatBuffer pjpl,
FloatBuffer pjspl,
FloatBuffer prpl,
String debugfile) |
static int |
lept.pixMeasureEdgeSmoothness(PIX pixs,
int side,
int minjump,
int minreversal,
FloatPointer pjpl,
FloatPointer pjspl,
FloatPointer prpl,
BytePointer debugfile) |
static int |
lept.pixMeasureEdgeSmoothness(PIX pixs,
int side,
int minjump,
int minreversal,
FloatPointer pjpl,
FloatPointer pjspl,
FloatPointer prpl,
String debugfile) |
static int |
lept.pixMeasureSaturation(PIX pixs,
int factor,
float[] psat) |
static int |
lept.pixMeasureSaturation(PIX pixs,
int factor,
FloatBuffer psat) |
static int |
lept.pixMeasureSaturation(PIX pixs,
int factor,
FloatPointer psat) |
static IntPointer |
lept.pixMedianCutHisto(PIX pixs,
int sigbits,
int subsample) |
static PIX |
lept.pixMedianCutQuant(PIX pixs,
int ditherflag) |
static PIX |
lept.pixMedianCutQuantGeneral(PIX pixs,
int ditherflag,
int outdepth,
int maxcolors,
int sigbits,
int maxsub,
int checkbw) |
static PIX |
lept.pixMedianCutQuantMixed(PIX pixs,
int ncolor,
int ngray,
int darkthresh,
int lightthresh,
int diffthresh) |
static PIX |
lept.pixMedianFilter(PIX pixs,
int wf,
int hf) |
static int |
lept.pixMinMaxNearLine(PIX pixs,
int x1,
int y1,
int x2,
int y2,
int dist,
int direction,
NUMA pnamin,
NUMA pnamax,
float[] pminave,
float[] pmaxave) |
static int |
lept.pixMinMaxNearLine(PIX pixs,
int x1,
int y1,
int x2,
int y2,
int dist,
int direction,
NUMA pnamin,
NUMA pnamax,
FloatBuffer pminave,
FloatBuffer pmaxave) |
static int |
lept.pixMinMaxNearLine(PIX pixs,
int x1,
int y1,
int x2,
int y2,
int dist,
int direction,
NUMA pnamin,
NUMA pnamax,
FloatPointer pminave,
FloatPointer pmaxave) |
static int |
lept.pixMinMaxNearLine(PIX pixs,
int x1,
int y1,
int x2,
int y2,
int dist,
int direction,
PointerPointer pnamin,
PointerPointer pnamax,
FloatPointer pminave,
FloatPointer pmaxave) |
static PIX |
lept.pixMinOrMax(PIX pixd,
PIX pixs1,
PIX pixs2,
int type) |
static int |
lept.pixMirrorDetect(PIX pixs,
float[] pconf,
int mincount,
int debug) |
static int |
lept.pixMirrorDetect(PIX pixs,
FloatBuffer pconf,
int mincount,
int debug) |
static int |
lept.pixMirrorDetect(PIX pixs,
FloatPointer pconf,
int mincount,
int debug) |
static PIX |
lept.pixMirroredTiling(PIX pixs,
int w,
int h) |
static PIX |
lept.pixModifyBrightness(PIX pixd,
PIX pixs,
float fract) |
static PIX |
lept.pixModifyHue(PIX pixd,
PIX pixs,
float fract) |
static PIX |
lept.pixModifySaturation(PIX pixd,
PIX pixs,
float fract) |
static PIX |
lept.pixModifyStrokeWidth(PIX pixs,
float width,
float targetw) |
static PIX |
lept.pixMorphCompSequence(PIX pixs,
BytePointer sequence,
int dispsep) |
static PIX |
lept.pixMorphCompSequence(PIX pixs,
String sequence,
int dispsep) |
static PIX |
lept.pixMorphCompSequenceDwa(PIX pixs,
BytePointer sequence,
int dispsep) |
static PIX |
lept.pixMorphCompSequenceDwa(PIX pixs,
String sequence,
int dispsep) |
static PIX |
lept.pixMorphDwa_1(PIX pixd,
PIX pixs,
int operation,
byte[] selname) |
static PIX |
lept.pixMorphDwa_1(PIX pixd,
PIX pixs,
int operation,
ByteBuffer selname) |
static PIX |
lept.pixMorphDwa_1(PIX pixd,
PIX pixs,
int operation,
BytePointer selname) |
static PIX |
lept.pixMorphDwa_2(PIX pixd,
PIX pixs,
int operation,
byte[] selname) |
static PIX |
lept.pixMorphDwa_2(PIX pixd,
PIX pixs,
int operation,
ByteBuffer selname) |
static PIX |
lept.pixMorphDwa_2(PIX pixd,
PIX pixs,
int operation,
BytePointer selname) |
static PIX |
lept.pixMorphGradient(PIX pixs,
int hsize,
int vsize,
int smoothing) |
static PIX |
lept.pixMorphSequence(PIX pixs,
BytePointer sequence,
int dispsep) |
static PIX |
lept.pixMorphSequence(PIX pixs,
String sequence,
int dispsep) |
static PIX |
lept.pixMorphSequenceByComponent(PIX pixs,
BytePointer sequence,
int connectivity,
int minw,
int minh,
BOXA pboxa) |
static PIX |
lept.pixMorphSequenceByComponent(PIX pixs,
BytePointer sequence,
int connectivity,
int minw,
int minh,
PointerPointer pboxa) |
static PIX |
lept.pixMorphSequenceByComponent(PIX pixs,
String sequence,
int connectivity,
int minw,
int minh,
BOXA pboxa) |
static PIX |
lept.pixMorphSequenceByRegion(PIX pixs,
PIX pixm,
BytePointer sequence,
int connectivity,
int minw,
int minh,
BOXA pboxa) |
static PIX |
lept.pixMorphSequenceByRegion(PIX pixs,
PIX pixm,
BytePointer sequence,
int connectivity,
int minw,
int minh,
PointerPointer pboxa) |
static PIX |
lept.pixMorphSequenceByRegion(PIX pixs,
PIX pixm,
String sequence,
int connectivity,
int minw,
int minh,
BOXA pboxa) |
static PIX |
lept.pixMorphSequenceDwa(PIX pixs,
BytePointer sequence,
int dispsep) |
static PIX |
lept.pixMorphSequenceDwa(PIX pixs,
String sequence,
int dispsep) |
static PIX |
lept.pixMorphSequenceMasked(PIX pixs,
PIX pixm,
BytePointer sequence,
int dispsep) |
static PIX |
lept.pixMorphSequenceMasked(PIX pixs,
PIX pixm,
String sequence,
int dispsep) |
static PIX |
lept.pixMosaicColorShiftRGB(PIX pixs,
float roff,
float goff,
float boff,
float delta,
int nincr) |
static int |
lept.pixMultConstAccumulate(PIX pixs,
float factor,
int offset) |
static PIX |
lept.pixMultConstantColor(PIX pixs,
float rfact,
float gfact,
float bfact) |
static int |
lept.pixMultConstantGray(PIX pixs,
float val) |
static PIX |
lept.pixMultiplyByColor(PIX pixd,
PIX pixs,
BOX box,
int color) |
static PIX |
lept.pixMultiplyGray(PIX pixs,
PIX pixg,
float norm) |
static PIX |
lept.pixMultMatrixColor(PIX pixs,
L_KERNEL kel) |
static int |
lept.pixNumberOccupiedOctcubes(PIX pix,
int level,
int mincount,
float minfract,
int[] pncolors) |
static int |
lept.pixNumberOccupiedOctcubes(PIX pix,
int level,
int mincount,
float minfract,
IntBuffer pncolors) |
static int |
lept.pixNumberOccupiedOctcubes(PIX pix,
int level,
int mincount,
float minfract,
IntPointer pncolors) |
static int |
lept.pixNumColors(PIX pixs,
int factor,
int[] pncolors) |
static int |
lept.pixNumColors(PIX pixs,
int factor,
IntBuffer pncolors) |
static int |
lept.pixNumColors(PIX pixs,
int factor,
IntPointer pncolors) |
static int |
lept.pixNumSignificantGrayColors(PIX pixs,
int darkthresh,
int lightthresh,
float minfract,
int factor,
int[] pncolors) |
static int |
lept.pixNumSignificantGrayColors(PIX pixs,
int darkthresh,
int lightthresh,
float minfract,
int factor,
IntBuffer pncolors) |
static int |
lept.pixNumSignificantGrayColors(PIX pixs,
int darkthresh,
int lightthresh,
float minfract,
int factor,
IntPointer pncolors) |
static NUMA |
lept.pixOctcubeHistogram(PIX pixs,
int level,
int[] pncolors) |
static NUMA |
lept.pixOctcubeHistogram(PIX pixs,
int level,
IntBuffer pncolors) |
static NUMA |
lept.pixOctcubeHistogram(PIX pixs,
int level,
IntPointer pncolors) |
static PIX |
lept.pixOctcubeQuantFromCmap(PIX pixs,
PIXCMAP cmap,
int mindepth,
int level,
int metric) |
static PIX |
lept.pixOctcubeQuantMixedWithGray(PIX pixs,
int depth,
int graylevels,
int delta) |
static PIX |
lept.pixOctreeColorQuant(PIX pixs,
int colors,
int ditherflag) |
static PIX |
lept.pixOctreeColorQuantGeneral(PIX pixs,
int colors,
int ditherflag,
float validthresh,
float colorthresh) |
static PIX |
lept.pixOctreeQuantByPopulation(PIX pixs,
int level,
int ditherflag) |
static PIX |
lept.pixOctreeQuantNumColors(PIX pixs,
int maxcolors,
int subsample) |
static PIX |
lept.pixOpen(PIX pixd,
PIX pixs,
SEL sel) |
static PIX |
lept.pixOpenBrick(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixOpenBrickDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixOpenCompBrick(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixOpenCompBrickDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixOpenCompBrickExtendDwa(PIX pixd,
PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixOpenGeneralized(PIX pixd,
PIX pixs,
SEL sel) |
static PIX |
lept.pixOpenGray(PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixOpenGray3(PIX pixs,
int hsize,
int vsize) |
static PIX |
lept.pixOr(PIX pixd,
PIX pixs1,
PIX pixs2) |
static PIX |
lept.pixOrientCorrect(PIX pixs,
float minupconf,
float minratio,
float[] pupconf,
float[] pleftconf,
int[] protation,
int debug) |
static PIX |
lept.pixOrientCorrect(PIX pixs,
float minupconf,
float minratio,
FloatBuffer pupconf,
FloatBuffer pleftconf,
IntBuffer protation,
int debug) |
static PIX |
lept.pixOrientCorrect(PIX pixs,
float minupconf,
float minratio,
FloatPointer pupconf,
FloatPointer pleftconf,
IntPointer protation,
int debug) |
static int |
lept.pixOrientDetect(PIX pixs,
float[] pupconf,
float[] pleftconf,
int mincount,
int debug) |
static int |
lept.pixOrientDetect(PIX pixs,
FloatBuffer pupconf,
FloatBuffer pleftconf,
int mincount,
int debug) |
static int |
lept.pixOrientDetect(PIX pixs,
FloatPointer pupconf,
FloatPointer pleftconf,
int mincount,
int debug) |
static int |
lept.pixOtsuAdaptiveThreshold(PIX pixs,
int sx,
int sy,
int smoothx,
int smoothy,
float scorefract,
PIX ppixth,
PIX ppixd) |
static int |
lept.pixOtsuAdaptiveThreshold(PIX pixs,
int sx,
int sy,
int smoothx,
int smoothy,
float scorefract,
PointerPointer ppixth,
PointerPointer ppixd) |
static PIX |
lept.pixOtsuThreshOnBackgroundNorm(PIX pixs,
PIX pixim,
int sx,
int sy,
int thresh,
int mincount,
int bgval,
int smoothx,
int smoothy,
float scorefract,
int[] pthresh) |
static PIX |
lept.pixOtsuThreshOnBackgroundNorm(PIX pixs,
PIX pixim,
int sx,
int sy,
int thresh,
int mincount,
int bgval,
int smoothx,
int smoothy,
float scorefract,
IntBuffer pthresh) |
static PIX |
lept.pixOtsuThreshOnBackgroundNorm(PIX pixs,
PIX pixim,
int sx,
int sy,
int thresh,
int mincount,
int bgval,
int smoothx,
int smoothy,
float scorefract,
IntPointer pthresh) |
static PIX |
lept.pixPadToCenterCentroid(PIX pixs,
int factor) |
static PIX |
lept.pixPaintBoxa(PIX pixs,
BOXA boxa,
int val) |
static PIX |
lept.pixPaintBoxaRandom(PIX pixs,
BOXA boxa) |
static int |
lept.pixPaintSelfThroughMask(PIX pixd,
PIX pixm,
int x,
int y,
int searchdir,
int mindist,
int tilesize,
int ntiles,
int distblend) |
static int |
lept.pixPaintThroughMask(PIX pixd,
PIX pixm,
int x,
int y,
int val) |
static int |
lept.pixPlotAlongPta(PIX pixs,
PTA pta,
int outformat,
BytePointer title) |
static int |
lept.pixPlotAlongPta(PIX pixs,
PTA pta,
int outformat,
String title) |
static PIX |
lept.pixPrepare1bpp(PIX pixs,
BOX box,
float cropfract,
int outres) |
static int |
lept.pixPrintStreamInfo(Pointer fp,
PIX pix,
BytePointer text) |
static int |
lept.pixPrintStreamInfo(Pointer fp,
PIX pix,
String text) |
static SARRAY |
lept.pixProcessBarcodes(PIX pixs,
int format,
int method,
PointerPointer psaw,
int debugflag) |
static SARRAY |
lept.pixProcessBarcodes(PIX pixs,
int format,
int method,
SARRAY psaw,
int debugflag) |
static PIX |
lept.pixProjective(PIX pixs,
float[] vc,
int incolor) |
static PIX |
lept.pixProjective(PIX pixs,
FloatBuffer vc,
int incolor) |
static PIX |
lept.pixProjective(PIX pixs,
FloatPointer vc,
int incolor) |
static PIX |
lept.pixProjectiveColor(PIX pixs,
float[] vc,
int colorval) |
static PIX |
lept.pixProjectiveColor(PIX pixs,
FloatBuffer vc,
int colorval) |
static PIX |
lept.pixProjectiveColor(PIX pixs,
FloatPointer vc,
int colorval) |
static PIX |
lept.pixProjectiveGray(PIX pixs,
float[] vc,
byte grayval) |
static PIX |
lept.pixProjectiveGray(PIX pixs,
FloatBuffer vc,
byte grayval) |
static PIX |
lept.pixProjectiveGray(PIX pixs,
FloatPointer vc,
byte grayval) |
static PIX |
lept.pixProjectivePta(PIX pixs,
PTA ptad,
PTA ptas,
int incolor) |
static PIX |
lept.pixProjectivePtaColor(PIX pixs,
PTA ptad,
PTA ptas,
int colorval) |
static PIX |
lept.pixProjectivePtaGray(PIX pixs,
PTA ptad,
PTA ptas,
byte grayval) |
static PIX |
lept.pixProjectivePtaWithAlpha(PIX pixs,
PTA ptad,
PTA ptas,
PIX pixg,
float fract,
int border) |
static PIX |
lept.pixProjectiveSampled(PIX pixs,
float[] vc,
int incolor) |
static PIX |
lept.pixProjectiveSampled(PIX pixs,
FloatBuffer vc,
int incolor) |
static PIX |
lept.pixProjectiveSampled(PIX pixs,
FloatPointer vc,
int incolor) |
static PIX |
lept.pixProjectiveSampledPta(PIX pixs,
PTA ptad,
PTA ptas,
int incolor) |
static PIX |
lept.pixQuadraticVShear(PIX pixs,
int dir,
int vmaxt,
int vmaxb,
int operation,
int incolor) |
static PIX |
lept.pixQuadraticVShearLI(PIX pixs,
int dir,
int vmaxt,
int vmaxb,
int incolor) |
static PIX |
lept.pixQuadraticVShearSampled(PIX pixs,
int dir,
int vmaxt,
int vmaxb,
int incolor) |
static int |
lept.pixQuadtreeMean(PIX pixs,
int nlevels,
PIX pix_ma,
FPIXA pfpixa) |
static int |
lept.pixQuadtreeMean(PIX pixs,
int nlevels,
PIX pix_ma,
PointerPointer pfpixa) |
static int |
lept.pixQuadtreeVariance(PIX pixs,
int nlevels,
PIX pix_ma,
DPIX dpix_msa,
FPIXA pfpixa_v,
FPIXA pfpixa_rv) |
static int |
lept.pixQuadtreeVariance(PIX pixs,
int nlevels,
PIX pix_ma,
DPIX dpix_msa,
PointerPointer pfpixa_v,
PointerPointer pfpixa_rv) |
static PIX |
lept.pixQuantFromCmap(PIX pixs,
PIXCMAP cmap,
int mindepth,
int level,
int metric) |
static int |
lept.pixQuantizeIfFewColors(PIX pixs,
int maxcolors,
int mingraycolors,
int octlevel,
PIX ppixd) |
static int |
lept.pixQuantizeIfFewColors(PIX pixs,
int maxcolors,
int mingraycolors,
int octlevel,
PointerPointer ppixd) |
static PIX |
lept.pixRandomHarmonicWarp(PIX pixs,
float xmag,
float ymag,
float xfreq,
float yfreq,
int nx,
int ny,
int seed,
int grayval) |
static PIX |
lept.pixRankBinByStrip(PIX pixs,
int direction,
int size,
int nbins,
int type) |
static PIX |
lept.pixRankColumnTransform(PIX pixs) |
static PIX |
lept.pixRankFilter(PIX pixs,
int wf,
int hf,
float rank) |
static PIX |
lept.pixRankFilterGray(PIX pixs,
int wf,
int hf,
float rank) |
static PIX |
lept.pixRankFilterRGB(PIX pixs,
int wf,
int hf,
float rank) |
static PIX |
lept.pixRankFilterWithScaling(PIX pixs,
int wf,
int hf,
float rank,
float scalefactor) |
static int |
lept.pixRankHaustest(PIX pix1,
PIX pix2,
PIX pix3,
PIX pix4,
float delx,
float dely,
int maxdiffw,
int maxdiffh,
int area1,
int area3,
float rank,
int[] tab8) |
static int |
lept.pixRankHaustest(PIX pix1,
PIX pix2,
PIX pix3,
PIX pix4,
float delx,
float dely,
int maxdiffw,
int maxdiffh,
int area1,
int area3,
float rank,
IntBuffer tab8) |
static int |
lept.pixRankHaustest(PIX pix1,
PIX pix2,
PIX pix3,
PIX pix4,
float delx,
float dely,
int maxdiffw,
int maxdiffh,
int area1,
int area3,
float rank,
IntPointer tab8) |
static PIX |
lept.pixRankRowTransform(PIX pixs) |
static int |
lept.pixRasterop(PIX pixd,
int dx,
int dy,
int dw,
int dh,
int op,
PIX pixs,
int sx,
int sy) |
static int |
lept.pixRasteropFullImage(PIX pixd,
PIX pixs,
int op) |
static int |
lept.pixRasteropHip(PIX pixd,
int by,
int bh,
int hshift,
int incolor) |
static int |
lept.pixRasteropIP(PIX pixd,
int hshift,
int vshift,
int incolor) |
static int |
lept.pixRasteropVip(PIX pixd,
int bx,
int bw,
int vshift,
int incolor) |
static NUMA |
lept.pixReadBarcodeWidths(PIX pixs,
int method,
int debugflag) |
static PIX |
lept.pixReduceBinary2(PIX pixs,
byte[] intab) |
static PIX |
lept.pixReduceBinary2(PIX pixs,
ByteBuffer intab) |
static PIX |
lept.pixReduceBinary2(PIX pixs,
BytePointer intab) |
static PIX |
lept.pixReduceRankBinary2(PIX pixs,
int level,
byte[] intab) |
static PIX |
lept.pixReduceRankBinary2(PIX pixs,
int level,
ByteBuffer intab) |
static PIX |
lept.pixReduceRankBinary2(PIX pixs,
int level,
BytePointer intab) |
static PIX |
lept.pixReduceRankBinaryCascade(PIX pixs,
int level1,
int level2,
int level3,
int level4) |
static PIX |
lept.pixRemoveAlpha(PIX pixs) |
static PIX |
lept.pixRemoveBorder(PIX pixs,
int npix) |
static PIX |
lept.pixRemoveBorderConnComps(PIX pixs,
int connectivity) |
static PIX |
lept.pixRemoveBorderGeneral(PIX pixs,
int left,
int right,
int top,
int bot) |
static PIX |
lept.pixRemoveBorderToSize(PIX pixs,
int wd,
int hd) |
static PIX |
lept.pixRemoveColormap(PIX pixs,
int type) |
static PIX |
lept.pixRemoveColormapGeneral(PIX pixs,
int type,
int ifnocmap) |
static int |
lept.pixRemoveMatchedPattern(PIX pixs,
PIX pixp,
PIX pixe,
int x0,
int y0,
int dsize) |
static PIX |
lept.pixRemoveSeededComponents(PIX pixd,
PIX pixs,
PIX pixm,
int connectivity,
int bordersize) |
static int |
lept.pixRemoveUnusedColors(PIX pixs) |
static int |
lept.pixRemoveWithIndicator(PIX pixs,
PIXA pixa,
NUMA na) |
static int |
lept.pixRenderBox(PIX pix,
BOX box,
int width,
int op) |
static int |
lept.pixRenderBoxa(PIX pix,
BOXA boxa,
int width,
int op) |
static int |
lept.pixRenderBoxaArb(PIX pix,
BOXA boxa,
int width,
byte rval,
byte gval,
byte bval) |
static int |
lept.pixRenderBoxaBlend(PIX pix,
BOXA boxa,
int width,
byte rval,
byte gval,
byte bval,
float fract,
int removedups) |
static int |
lept.pixRenderBoxArb(PIX pix,
BOX box,
int width,
byte rval,
byte gval,
byte bval) |
static int |
lept.pixRenderBoxBlend(PIX pix,
BOX box,
int width,
byte rval,
byte gval,
byte bval,
float fract) |
static PIX |
lept.pixRenderContours(PIX pixs,
int startval,
int incr,
int outdepth) |
static int |
lept.pixRenderGridArb(PIX pix,
int nx,
int ny,
int width,
byte rval,
byte gval,
byte bval) |
static int |
lept.pixRenderHashBox(PIX pix,
BOX box,
int spacing,
int width,
int orient,
int outline,
int op) |
static int |
lept.pixRenderHashBoxa(PIX pix,
BOXA boxa,
int spacing,
int width,
int orient,
int outline,
int op) |
static int |
lept.pixRenderHashBoxaArb(PIX pix,
BOXA boxa,
int spacing,
int width,
int orient,
int outline,
int rval,
int gval,
int bval) |
static int |
lept.pixRenderHashBoxaBlend(PIX pix,
BOXA boxa,
int spacing,
int width,
int orient,
int outline,
int rval,
int gval,
int bval,
float fract) |
static int |
lept.pixRenderHashBoxArb(PIX pix,
BOX box,
int spacing,
int width,
int orient,
int outline,
int rval,
int gval,
int bval) |
static int |
lept.pixRenderHashBoxBlend(PIX pix,
BOX box,
int spacing,
int width,
int orient,
int outline,
int rval,
int gval,
int bval,
float fract) |
static int |
lept.pixRenderHashMaskArb(PIX pix,
PIX pixm,
int x,
int y,
int spacing,
int width,
int orient,
int outline,
int rval,
int gval,
int bval) |
static int |
lept.pixRenderLine(PIX pix,
int x1,
int y1,
int x2,
int y2,
int width,
int op) |
static int |
lept.pixRenderLineArb(PIX pix,
int x1,
int y1,
int x2,
int y2,
int width,
byte rval,
byte gval,
byte bval) |
static int |
lept.pixRenderLineBlend(PIX pix,
int x1,
int y1,
int x2,
int y2,
int width,
byte rval,
byte gval,
byte bval,
float fract) |
static int |
lept.pixRenderPlotFromNuma(PIX ppix,
NUMA na,
int plotloc,
int linewidth,
int max,
int color) |
static int |
lept.pixRenderPlotFromNumaGen(PIX ppix,
NUMA na,
int orient,
int linewidth,
int refpos,
int max,
int drawref,
int color) |
static int |
lept.pixRenderPolyline(PIX pix,
PTA ptas,
int width,
int op,
int closeflag) |
static int |
lept.pixRenderPolylineArb(PIX pix,
PTA ptas,
int width,
byte rval,
byte gval,
byte bval,
int closeflag) |
static int |
lept.pixRenderPolylineBlend(PIX pix,
PTA ptas,
int width,
byte rval,
byte gval,
byte bval,
float fract,
int closeflag,
int removedups) |
static int |
lept.pixRenderPta(PIX pix,
PTA pta,
int op) |
static int |
lept.pixRenderPtaArb(PIX pix,
PTA pta,
byte rval,
byte gval,
byte bval) |
static int |
lept.pixRenderPtaBlend(PIX pix,
PTA pta,
byte rval,
byte gval,
byte bval,
float fract) |
static PIX |
lept.pixRenderRandomCmapPtaa(PIX pix,
PTAA ptaa,
int polyflag,
int width,
int closeflag) |
static int |
lept.pixResizeImageData(PIX pixd,
PIX pixs) |
static PIX |
lept.pixResizeToMatch(PIX pixs,
PIX pixt,
int w,
int h) |
static NUMA |
lept.pixReversalProfile(PIX pixs,
float fract,
int dir,
int first,
int last,
int minreversal,
int factor1,
int factor2) |
static PIX |
lept.pixRotate(PIX pixs,
float angle,
int type,
int incolor,
int width,
int height) |
static PIX |
lept.pixRotate180(PIX pixd,
PIX pixs) |
static PIX |
lept.pixRotate2Shear(PIX pixs,
int xcen,
int ycen,
float angle,
int incolor) |
static PIX |
lept.pixRotate3Shear(PIX pixs,
int xcen,
int ycen,
float angle,
int incolor) |
static PIX |
lept.pixRotate90(PIX pixs,
int direction) |
static PIX |
lept.pixRotateAM(PIX pixs,
float angle,
int incolor) |
static PIX |
lept.pixRotateAMColor(PIX pixs,
float angle,
int colorval) |
static PIX |
lept.pixRotateAMColorCorner(PIX pixs,
float angle,
int fillval) |
static PIX |
lept.pixRotateAMColorFast(PIX pixs,
float angle,
int colorval) |
static PIX |
lept.pixRotateAMCorner(PIX pixs,
float angle,
int incolor) |
static PIX |
lept.pixRotateAMGray(PIX pixs,
float angle,
byte grayval) |
static PIX |
lept.pixRotateAMGrayCorner(PIX pixs,
float angle,
byte grayval) |
static PIX |
lept.pixRotateBinaryNice(PIX pixs,
float angle,
int incolor) |
static PIX |
lept.pixRotateBySampling(PIX pixs,
int xcen,
int ycen,
float angle,
int incolor) |
static PIX |
lept.pixRotateOrth(PIX pixs,
int quads) |
static PIX |
lept.pixRotateShear(PIX pixs,
int xcen,
int ycen,
float angle,
int incolor) |
static PIX |
lept.pixRotateShearCenter(PIX pixs,
float angle,
int incolor) |
static int |
lept.pixRotateShearCenterIP(PIX pixs,
float angle,
int incolor) |
static int |
lept.pixRotateShearIP(PIX pixs,
int xcen,
int ycen,
float angle,
int incolor) |
static PIX |
lept.pixRotateWithAlpha(PIX pixs,
float angle,
PIX pixg,
float fract) |
static int |
lept.pixRowStats(PIX pixs,
BOX box,
NUMA pnamean,
NUMA pnamedian,
NUMA pnamode,
NUMA pnamodecount,
NUMA pnavar,
NUMA pnarootvar) |
static int |
lept.pixRowStats(PIX pixs,
BOX box,
PointerPointer pnamean,
PointerPointer pnamedian,
PointerPointer pnamode,
PointerPointer pnamodecount,
PointerPointer pnavar,
PointerPointer pnarootvar) |
static NUMA |
lept.pixRunHistogramMorph(PIX pixs,
int runtype,
int direction,
int maxsize) |
static PIX |
lept.pixRunlengthTransform(PIX pixs,
int color,
int direction,
int depth) |
static int |
lept.pixSauvolaBinarize(PIX pixs,
int whsize,
float factor,
int addborder,
PIX ppixm,
PIX ppixsd,
PIX ppixth,
PIX ppixd) |
static int |
lept.pixSauvolaBinarize(PIX pixs,
int whsize,
float factor,
int addborder,
PointerPointer ppixm,
PointerPointer ppixsd,
PointerPointer ppixth,
PointerPointer ppixd) |
static int |
lept.pixSauvolaBinarizeTiled(PIX pixs,
int whsize,
float factor,
int nx,
int ny,
PIX ppixth,
PIX ppixd) |
static int |
lept.pixSauvolaBinarizeTiled(PIX pixs,
int whsize,
float factor,
int nx,
int ny,
PointerPointer ppixth,
PointerPointer ppixd) |
static PIX |
lept.pixSauvolaOnContrastNorm(PIX pixs,
int mindiff,
PIX ppixn,
PIX ppixth) |
static PIX |
lept.pixSauvolaOnContrastNorm(PIX pixs,
int mindiff,
PointerPointer ppixn,
PointerPointer ppixth) |
static PIX |
lept.pixScale(PIX pixs,
float scalex,
float scaley) |
static int |
lept.pixScaleAndTransferAlpha(PIX pixd,
PIX pixs,
float scalex,
float scaley) |
static PIX |
lept.pixScaleAreaMap(PIX pix,
float scalex,
float scaley) |
static PIX |
lept.pixScaleAreaMap2(PIX pix) |
static PIX |
lept.pixScaleAreaMapToSize(PIX pixs,
int wd,
int hd) |
static PIX |
lept.pixScaleBinary(PIX pixs,
float scalex,
float scaley) |
static PIX |
lept.pixScaleByIntSampling(PIX pixs,
int factor) |
static PIX |
lept.pixScaleBySampling(PIX pixs,
float scalex,
float scaley) |
static PIX |
lept.pixScaleBySamplingToSize(PIX pixs,
int wd,
int hd) |
static PIX |
lept.pixScaleColor2xLI(PIX pixs) |
static PIX |
lept.pixScaleColor4xLI(PIX pixs) |
static PIX |
lept.pixScaleColorLI(PIX pixs,
float scalex,
float scaley) |
static PIX |
lept.pixScaleGeneral(PIX pixs,
float scalex,
float scaley,
float sharpfract,
int sharpwidth) |
static PIX |
lept.pixScaleGray2xLI(PIX pixs) |
static PIX |
lept.pixScaleGray2xLIDither(PIX pixs) |
static PIX |
lept.pixScaleGray2xLIThresh(PIX pixs,
int thresh) |
static PIX |
lept.pixScaleGray4xLI(PIX pixs) |
static PIX |
lept.pixScaleGray4xLIDither(PIX pixs) |
static PIX |
lept.pixScaleGray4xLIThresh(PIX pixs,
int thresh) |
static PIX |
lept.pixScaleGrayLI(PIX pixs,
float scalex,
float scaley) |
static PIX |
lept.pixScaleGrayMinMax(PIX pixs,
int xfact,
int yfact,
int type) |
static PIX |
lept.pixScaleGrayMinMax2(PIX pixs,
int type) |
static PIX |
lept.pixScaleGrayRank2(PIX pixs,
int rank) |
static PIX |
lept.pixScaleGrayRankCascade(PIX pixs,
int level1,
int level2,
int level3,
int level4) |
static PIX |
lept.pixScaleGrayToBinaryFast(PIX pixs,
int factor,
int thresh) |
static PIX |
lept.pixScaleLI(PIX pixs,
float scalex,
float scaley) |
static PIX |
lept.pixScaleMipmap(PIX pixs1,
PIX pixs2,
float scale) |
static int |
lept.pixScaleResolution(PIX pix,
float xscale,
float yscale) |
static PIX |
lept.pixScaleRGBToBinaryFast(PIX pixs,
int factor,
int thresh) |
static PIX |
lept.pixScaleRGBToGray2(PIX pixs,
float rwt,
float gwt,
float bwt) |
static PIX |
lept.pixScaleRGBToGrayFast(PIX pixs,
int factor,
int color) |
static PIX |
lept.pixScaleSmooth(PIX pix,
float scalex,
float scaley) |
static PIX |
lept.pixScaleSmoothToSize(PIX pixs,
int wd,
int hd) |
static PIX |
lept.pixScaleToGray(PIX pixs,
float scalefactor) |
static PIX |
lept.pixScaleToGray16(PIX pixs) |
static PIX |
lept.pixScaleToGray2(PIX pixs) |
static PIX |
lept.pixScaleToGray3(PIX pixs) |
static PIX |
lept.pixScaleToGray4(PIX pixs) |
static PIX |
lept.pixScaleToGray6(PIX pixs) |
static PIX |
lept.pixScaleToGray8(PIX pixs) |
static PIX |
lept.pixScaleToGrayFast(PIX pixs,
float scalefactor) |
static PIX |
lept.pixScaleToGrayMipmap(PIX pixs,
float scalefactor) |
static PIX |
lept.pixScaleToResolution(PIX pixs,
float target,
float assumed,
float[] pscalefact) |
static PIX |
lept.pixScaleToResolution(PIX pixs,
float target,
float assumed,
FloatBuffer pscalefact) |
static PIX |
lept.pixScaleToResolution(PIX pixs,
float target,
float assumed,
FloatPointer pscalefact) |
static PIX |
lept.pixScaleToSize(PIX pixs,
int wd,
int hd) |
static PIX |
lept.pixScaleToSizeRel(PIX pixs,
int delw,
int delh) |
static PIX |
lept.pixScaleWithAlpha(PIX pixs,
float scalex,
float scaley,
PIX pixg,
float fract) |
static int |
lept.pixScanForEdge(PIX pixs,
BOX box,
int lowthresh,
int highthresh,
int maxwidth,
int factor,
int scanflag,
int[] ploc) |
static int |
lept.pixScanForEdge(PIX pixs,
BOX box,
int lowthresh,
int highthresh,
int maxwidth,
int factor,
int scanflag,
IntBuffer ploc) |
static int |
lept.pixScanForEdge(PIX pixs,
BOX box,
int lowthresh,
int highthresh,
int maxwidth,
int factor,
int scanflag,
IntPointer ploc) |
static int |
lept.pixScanForForeground(PIX pixs,
BOX box,
int scanflag,
int[] ploc) |
static int |
lept.pixScanForForeground(PIX pixs,
BOX box,
int scanflag,
IntBuffer ploc) |
static int |
lept.pixScanForForeground(PIX pixs,
BOX box,
int scanflag,
IntPointer ploc) |
static PTA |
lept.pixSearchBinaryMaze(PIX pixs,
int xi,
int yi,
int xf,
int yf,
PIX ppixd) |
static PTA |
lept.pixSearchBinaryMaze(PIX pixs,
int xi,
int yi,
int xf,
int yf,
PointerPointer ppixd) |
static PTA |
lept.pixSearchGrayMaze(PIX pixs,
int xi,
int yi,
int xf,
int yf,
PIX ppixd) |
static PTA |
lept.pixSearchGrayMaze(PIX pixs,
int xi,
int yi,
int xf,
int yf,
PointerPointer ppixd) |
static int |
lept.pixSeedfill(PIX pixs,
L_STACK stack,
int x,
int y,
int connectivity) |
static int |
lept.pixSeedfill4(PIX pixs,
L_STACK stack,
int x,
int y) |
static BOX |
lept.pixSeedfill4BB(PIX pixs,
L_STACK stack,
int x,
int y) |
static int |
lept.pixSeedfill8(PIX pixs,
L_STACK stack,
int x,
int y) |
static BOX |
lept.pixSeedfill8BB(PIX pixs,
L_STACK stack,
int x,
int y) |
static BOX |
lept.pixSeedfillBB(PIX pixs,
L_STACK stack,
int x,
int y,
int connectivity) |
static PIX |
lept.pixSeedfillBinary(PIX pixd,
PIX pixs,
PIX pixm,
int connectivity) |
static PIX |
lept.pixSeedfillBinaryRestricted(PIX pixd,
PIX pixs,
PIX pixm,
int connectivity,
int xmax,
int ymax) |
static int |
lept.pixSeedfillGray(PIX pixs,
PIX pixm,
int connectivity) |
static PIX |
lept.pixSeedfillGrayBasin(PIX pixb,
PIX pixm,
int delta,
int connectivity) |
static int |
lept.pixSeedfillGrayInv(PIX pixs,
PIX pixm,
int connectivity) |
static int |
lept.pixSeedfillGrayInvSimple(PIX pixs,
PIX pixm,
int connectivity) |
static int |
lept.pixSeedfillGraySimple(PIX pixs,
PIX pixm,
int connectivity) |
static PIX |
lept.pixSeedfillMorph(PIX pixs,
PIX pixm,
int maxiters,
int connectivity) |
static PIX |
lept.pixSeedspread(PIX pixs,
int connectivity) |
static PIX |
lept.pixSelectByArea(PIX pixs,
float thresh,
int connectivity,
int type,
int[] pchanged) |
static PIX |
lept.pixSelectByArea(PIX pixs,
float thresh,
int connectivity,
int type,
IntBuffer pchanged) |
static PIX |
lept.pixSelectByArea(PIX pixs,
float thresh,
int connectivity,
int type,
IntPointer pchanged) |
static PIX |
lept.pixSelectByAreaFraction(PIX pixs,
float thresh,
int connectivity,
int type,
int[] pchanged) |
static PIX |
lept.pixSelectByAreaFraction(PIX pixs,
float thresh,
int connectivity,
int type,
IntBuffer pchanged) |
static PIX |
lept.pixSelectByAreaFraction(PIX pixs,
float thresh,
int connectivity,
int type,
IntPointer pchanged) |
static PIX |
lept.pixSelectByPerimSizeRatio(PIX pixs,
float thresh,
int connectivity,
int type,
int[] pchanged) |
static PIX |
lept.pixSelectByPerimSizeRatio(PIX pixs,
float thresh,
int connectivity,
int type,
IntBuffer pchanged) |
static PIX |
lept.pixSelectByPerimSizeRatio(PIX pixs,
float thresh,
int connectivity,
int type,
IntPointer pchanged) |
static PIX |
lept.pixSelectByPerimToAreaRatio(PIX pixs,
float thresh,
int connectivity,
int type,
int[] pchanged) |
static PIX |
lept.pixSelectByPerimToAreaRatio(PIX pixs,
float thresh,
int connectivity,
int type,
IntBuffer pchanged) |
static PIX |
lept.pixSelectByPerimToAreaRatio(PIX pixs,
float thresh,
int connectivity,
int type,
IntPointer pchanged) |
static PIX |
lept.pixSelectBySize(PIX pixs,
int width,
int height,
int connectivity,
int type,
int relation,
int[] pchanged) |
static PIX |
lept.pixSelectBySize(PIX pixs,
int width,
int height,
int connectivity,
int type,
int relation,
IntBuffer pchanged) |
static PIX |
lept.pixSelectBySize(PIX pixs,
int width,
int height,
int connectivity,
int type,
int relation,
IntPointer pchanged) |
static PIX |
lept.pixSelectByWidthHeightRatio(PIX pixs,
float thresh,
int connectivity,
int type,
int[] pchanged) |
static PIX |
lept.pixSelectByWidthHeightRatio(PIX pixs,
float thresh,
int connectivity,
int type,
IntBuffer pchanged) |
static PIX |
lept.pixSelectByWidthHeightRatio(PIX pixs,
float thresh,
int connectivity,
int type,
IntPointer pchanged) |
static PIX |
lept.pixSelectComponentBySize(PIX pixs,
int rankorder,
int type,
int connectivity,
BOX pbox) |
static PIX |
lept.pixSelectComponentBySize(PIX pixs,
int rankorder,
int type,
int connectivity,
PointerPointer pbox) |
static int |
lept.pixSelectedLocalExtrema(PIX pixs,
int mindist,
PIX ppixmin,
PIX ppixmax) |
static int |
lept.pixSelectedLocalExtrema(PIX pixs,
int mindist,
PointerPointer ppixmin,
PointerPointer ppixmax) |
static PIX |
lept.pixSelectiveConnCompFill(PIX pixs,
int connectivity,
int minw,
int minh) |
static BOX |
lept.pixSelectLargeULComp(PIX pixs,
float areaslop,
int yslop,
int connectivity) |
static int |
lept.pixSelectMinInConnComp(PIX pixs,
PIX pixm,
PointerPointer ppta,
PointerPointer pnav) |
static int |
lept.pixSelectMinInConnComp(PIX pixs,
PIX pixm,
PTA ppta,
NUMA pnav) |
static int |
lept.pixSerializeToMemory(PIX pixs,
int[] pdata,
SizeTPointer pnbytes) |
static int |
lept.pixSerializeToMemory(PIX pixs,
IntBuffer pdata,
SizeTPointer pnbytes) |
static int |
lept.pixSerializeToMemory(PIX pixs,
IntPointer pdata,
SizeTPointer pnbytes) |
static int |
lept.pixSerializeToMemory(PIX pixs,
PointerPointer pdata,
SizeTPointer pnbytes) |
static int |
lept.pixSetAll(PIX pix) |
static int |
lept.pixSetAllArbitrary(PIX pix,
int val) |
static int |
lept.pixSetAllGray(PIX pix,
int grayval) |
static PIX |
lept.pixSetAlphaOverWhite(PIX pixs) |
static int |
lept.pixSetBlackOrWhite(PIX pixs,
int op) |
static PIX |
lept.pixSetBlackOrWhiteBoxa(PIX pixs,
BOXA boxa,
int op) |
static int |
lept.pixSetBorderRingVal(PIX pixs,
int dist,
int val) |
static int |
lept.pixSetBorderVal(PIX pixs,
int left,
int right,
int top,
int bot,
int val) |
static int |
lept.pixSetChromaSampling(PIX pix,
int sampling) |
static int |
lept.pixSetCmapPixel(PIX pix,
int x,
int y,
int rval,
int gval,
int bval) |
static int |
lept.pixSetColormap(PIX pix,
PIXCMAP colormap) |
static int |
lept.pixSetComponentArbitrary(PIX pix,
int comp,
int val) |
static int |
lept.pixSetData(PIX pix,
int[] data) |
static int |
lept.pixSetData(PIX pix,
IntBuffer data) |
static int |
lept.pixSetData(PIX pix,
IntPointer data) |
static int |
lept.pixSetDepth(PIX pix,
int depth) |
static int |
lept.pixSetDimensions(PIX pix,
int w,
int h,
int d) |
static int |
lept.pixSetHeight(PIX pix,
int height) |
static int |
lept.pixSetInputFormat(PIX pix,
int informat) |
static int |
lept.pixSetInRect(PIX pix,
BOX box) |
static int |
lept.pixSetInRectArbitrary(PIX pix,
BOX box,
int val) |
static int |
lept.pixSetMasked(PIX pixd,
PIX pixm,
int val) |
static int |
lept.pixSetMaskedCmap(PIX pixs,
PIX pixm,
int x,
int y,
int rval,
int gval,
int bval) |
static int |
lept.pixSetMaskedGeneral(PIX pixd,
PIX pixm,
int val,
int x,
int y) |
static int |
lept.pixSetMirroredBorder(PIX pixs,
int left,
int right,
int top,
int bot) |
static int |
lept.pixSetOrClearBorder(PIX pixs,
int left,
int right,
int top,
int bot,
int op) |
static int |
lept.pixSetPadBits(PIX pix,
int val) |
static int |
lept.pixSetPadBitsBand(PIX pix,
int by,
int bh,
int val) |
static int |
lept.pixSetPixel(PIX pix,
int x,
int y,
int val) |
static int |
lept.pixSetPixelColumn(PIX pix,
int col,
float[] colvect) |
static int |
lept.pixSetPixelColumn(PIX pix,
int col,
FloatBuffer colvect) |
static int |
lept.pixSetPixelColumn(PIX pix,
int col,
FloatPointer colvect) |
static int |
lept.pixSetResolution(PIX pix,
int xres,
int yres) |
static int |
lept.pixSetRGBComponent(PIX pixd,
PIX pixs,
int comp) |
static int |
lept.pixSetRGBPixel(PIX pix,
int x,
int y,
int rval,
int gval,
int bval) |
static int |
lept.pixSetSelectCmap(PIX pixs,
BOX box,
int sindex,
int rval,
int gval,
int bval) |
static int |
lept.pixSetSelectMaskedCmap(PIX pixs,
PIX pixm,
int x,
int y,
int sindex,
int rval,
int gval,
int bval) |
static int |
lept.pixSetSpecial(PIX pix,
int special) |
static int |
lept.pixSetSpp(PIX pix,
int spp) |
static PIX |
lept.pixSetStrokeWidth(PIX pixs,
int width,
int thinfirst,
int connectivity) |
static int |
lept.pixSetText(PIX pix,
BytePointer textstring) |
static int |
lept.pixSetText(PIX pix,
String textstring) |
static int |
lept.pixSetTextblock(PIX pixs,
L_BMF bmf,
BytePointer textstr,
int val,
int x0,
int y0,
int wtext,
int firstindent,
int[] poverflow) |
static int |
lept.pixSetTextblock(PIX pixs,
L_BMF bmf,
BytePointer textstr,
int val,
int x0,
int y0,
int wtext,
int firstindent,
IntBuffer poverflow) |
static int |
lept.pixSetTextblock(PIX pixs,
L_BMF bmf,
BytePointer textstr,
int val,
int x0,
int y0,
int wtext,
int firstindent,
IntPointer poverflow) |
static int |
lept.pixSetTextblock(PIX pixs,
L_BMF bmf,
String textstr,
int val,
int x0,
int y0,
int wtext,
int firstindent,
int[] poverflow) |
static int |
lept.pixSetTextblock(PIX pixs,
L_BMF bmf,
String textstr,
int val,
int x0,
int y0,
int wtext,
int firstindent,
IntBuffer poverflow) |
static int |
lept.pixSetTextblock(PIX pixs,
L_BMF bmf,
String textstr,
int val,
int x0,
int y0,
int wtext,
int firstindent,
IntPointer poverflow) |
static int |
lept.pixSetTextCompNew(PIX pix,
byte[] data,
long size) |
static int |
lept.pixSetTextCompNew(PIX pix,
ByteBuffer data,
long size) |
static int |
lept.pixSetTextCompNew(PIX pix,
BytePointer data,
long size) |
static int |
lept.pixSetTextline(PIX pixs,
L_BMF bmf,
BytePointer textstr,
int val,
int x0,
int y0,
int[] pwidth,
int[] poverflow) |
static int |
lept.pixSetTextline(PIX pixs,
L_BMF bmf,
BytePointer textstr,
int val,
int x0,
int y0,
IntBuffer pwidth,
IntBuffer poverflow) |
static int |
lept.pixSetTextline(PIX pixs,
L_BMF bmf,
BytePointer textstr,
int val,
int x0,
int y0,
IntPointer pwidth,
IntPointer poverflow) |
static int |
lept.pixSetTextline(PIX pixs,
L_BMF bmf,
String textstr,
int val,
int x0,
int y0,
int[] pwidth,
int[] poverflow) |
static int |
lept.pixSetTextline(PIX pixs,
L_BMF bmf,
String textstr,
int val,
int x0,
int y0,
IntBuffer pwidth,
IntBuffer poverflow) |
static int |
lept.pixSetTextline(PIX pixs,
L_BMF bmf,
String textstr,
int val,
int x0,
int y0,
IntPointer pwidth,
IntPointer poverflow) |
static PIX |
lept.pixSetUnderTransparency(PIX pixs,
int val,
int debug) |
static byte[] |
lept.pixSetupByteProcessing(PIX pix,
int[] pw,
int[] ph) |
static ByteBuffer |
lept.pixSetupByteProcessing(PIX pix,
IntBuffer pw,
IntBuffer ph) |
static PointerPointer |
lept.pixSetupByteProcessing(PIX pix,
IntPointer pw,
IntPointer ph) |
static int |
lept.pixSetWidth(PIX pix,
int width) |
static int |
lept.pixSetWpl(PIX pix,
int wpl) |
static int |
lept.pixSetXRes(PIX pix,
int res) |
static int |
lept.pixSetYRes(PIX pix,
int res) |
static int |
lept.pixSetZlibCompression(PIX pix,
int compval) |
static int |
lept.pixShiftAndTransferAlpha(PIX pixd,
PIX pixs,
float shiftx,
float shifty) |
static PIX |
lept.pixShiftByComponent(PIX pixd,
PIX pixs,
int srcval,
int dstval) |
static PIX |
lept.pixSimpleCaptcha(PIX pixs,
int border,
int nterms,
int seed,
int color,
int cmapflag) |
static PIX |
lept.pixSimpleColorQuantize(PIX pixs,
int sigbits,
int factor,
int ncolors) |
static int |
lept.pixSizesEqual(PIX pix1,
PIX pix2) |
static int |
lept.pixSmoothConnectedRegions(PIX pixs,
PIX pixm,
int factor) |
static PIX |
lept.pixSnapColor(PIX pixd,
PIX pixs,
int srcval,
int dstval,
int diff) |
static PIX |
lept.pixSnapColorCmap(PIX pixd,
PIX pixs,
int srcval,
int dstval,
int diff) |
static PIX |
lept.pixSobelEdgeFilter(PIX pixs,
int orientflag) |
static BOXA |
lept.pixSplitComponentIntoBoxa(PIX pix,
BOX box,
int minsum,
int skipdist,
int delta,
int maxbg,
int maxcomps,
int remainder) |
static BOXA |
lept.pixSplitComponentWithProfile(PIX pixs,
int delta,
int mindel,
PIX ppixdebug) |
static BOXA |
lept.pixSplitComponentWithProfile(PIX pixs,
int delta,
int mindel,
PointerPointer ppixdebug) |
static int |
lept.pixSplitDistributionFgBg(PIX pixs,
float scorefract,
int factor,
int[] pthresh,
int[] pfgval,
int[] pbgval,
PIX ppixdb) |
static int |
lept.pixSplitDistributionFgBg(PIX pixs,
float scorefract,
int factor,
IntBuffer pthresh,
IntBuffer pfgval,
IntBuffer pbgval,
PIX ppixdb) |
static int |
lept.pixSplitDistributionFgBg(PIX pixs,
float scorefract,
int factor,
IntPointer pthresh,
IntPointer pfgval,
IntPointer pbgval,
PIX ppixdb) |
static int |
lept.pixSplitDistributionFgBg(PIX pixs,
float scorefract,
int factor,
IntPointer pthresh,
IntPointer pfgval,
IntPointer pbgval,
PointerPointer ppixdb) |
static BOXA |
lept.pixSplitIntoBoxa(PIX pixs,
int minsum,
int skipdist,
int delta,
int maxbg,
int maxcomps,
int remainder) |
static int |
lept.pixSplitIntoCharacters(PIX pixs,
int minw,
int minh,
BOXA pboxa,
PIXA ppixa,
PIX ppixdebug) |
static int |
lept.pixSplitIntoCharacters(PIX pixs,
int minw,
int minh,
PointerPointer pboxa,
PointerPointer ppixa,
PointerPointer ppixdebug) |
static PIX |
lept.pixStereoFromPair(PIX pix1,
PIX pix2,
float rwt,
float gwt,
float bwt) |
static PIX |
lept.pixStretchHorizontal(PIX pixs,
int dir,
int type,
int hmax,
int operation,
int incolor) |
static PIX |
lept.pixStretchHorizontalLI(PIX pixs,
int dir,
int type,
int hmax,
int incolor) |
static PIX |
lept.pixStretchHorizontalSampled(PIX pixs,
int dir,
int type,
int hmax,
int incolor) |
static PIX |
lept.pixStrokeWidthTransform(PIX pixs,
int color,
int depth,
int nangles) |
static PTA |
lept.pixSubsampleBoundaryPixels(PIX pixs,
int skip) |
static PIX |
lept.pixSubtract(PIX pixd,
PIX pixs1,
PIX pixs2) |
static PIX |
lept.pixSubtractGray(PIX pixd,
PIX pixs1,
PIX pixs2) |
static int |
lept.pixSwapAndDestroy(PIX ppixd,
PIX ppixs) |
static int |
lept.pixTestClipToForeground(PIX pixs,
int[] pcanclip) |
static int |
lept.pixTestClipToForeground(PIX pixs,
IntBuffer pcanclip) |
static int |
lept.pixTestClipToForeground(PIX pixs,
IntPointer pcanclip) |
static int |
lept.pixTestForSimilarity(PIX pix1,
PIX pix2,
int factor,
int mindiff,
float maxfract,
float maxave,
int[] psimilar,
int details) |
static int |
lept.pixTestForSimilarity(PIX pix1,
PIX pix2,
int factor,
int mindiff,
float maxfract,
float maxave,
IntBuffer psimilar,
int details) |
static int |
lept.pixTestForSimilarity(PIX pix1,
PIX pix2,
int factor,
int mindiff,
float maxfract,
float maxave,
IntPointer psimilar,
int details) |
static PIX |
lept.pixThinConnected(PIX pixs,
int type,
int connectivity,
int maxiters) |
static PIX |
lept.pixThinConnectedBySet(PIX pixs,
int type,
SELA sela,
int maxiters) |
static PIX |
lept.pixThreshold8(PIX pixs,
int d,
int nlevels,
int cmapflag) |
static int |
lept.pixThresholdByConnComp(PIX pixs,
PIX pixm,
int start,
int end,
int incr,
float thresh48,
float threshdiff,
int[] pglobthresh,
PIX ppixd,
int debugflag) |
static int |
lept.pixThresholdByConnComp(PIX pixs,
PIX pixm,
int start,
int end,
int incr,
float thresh48,
float threshdiff,
IntBuffer pglobthresh,
PIX ppixd,
int debugflag) |
static int |
lept.pixThresholdByConnComp(PIX pixs,
PIX pixm,
int start,
int end,
int incr,
float thresh48,
float threshdiff,
IntPointer pglobthresh,
PIX ppixd,
int debugflag) |
static int |
lept.pixThresholdByConnComp(PIX pixs,
PIX pixm,
int start,
int end,
int incr,
float thresh48,
float threshdiff,
IntPointer pglobthresh,
PointerPointer ppixd,
int debugflag) |
static int |
lept.pixThresholdByHisto(PIX pixs,
int factor,
int halfw,
float delta,
int[] pthresh,
PIX ppixd,
PIX ppixhisto) |
static int |
lept.pixThresholdByHisto(PIX pixs,
int factor,
int halfw,
float delta,
IntBuffer pthresh,
PIX ppixd,
PIX ppixhisto) |
static int |
lept.pixThresholdByHisto(PIX pixs,
int factor,
int halfw,
float delta,
IntPointer pthresh,
PIX ppixd,
PIX ppixhisto) |
static int |
lept.pixThresholdByHisto(PIX pixs,
int factor,
int halfw,
float delta,
IntPointer pthresh,
PointerPointer ppixd,
PointerPointer ppixhisto) |
static int |
lept.pixThresholdForFgBg(PIX pixs,
int factor,
int thresh,
int[] pfgval,
int[] pbgval) |
static int |
lept.pixThresholdForFgBg(PIX pixs,
int factor,
int thresh,
IntBuffer pfgval,
IntBuffer pbgval) |
static int |
lept.pixThresholdForFgBg(PIX pixs,
int factor,
int thresh,
IntPointer pfgval,
IntPointer pbgval) |
static PIX |
lept.pixThresholdGrayArb(PIX pixs,
BytePointer edgevals,
int outdepth,
int use_average,
int setblack,
int setwhite) |
static PIX |
lept.pixThresholdGrayArb(PIX pixs,
String edgevals,
int outdepth,
int use_average,
int setblack,
int setwhite) |
static PIX |
lept.pixThresholdOn8bpp(PIX pixs,
int nlevels,
int cmapflag) |
static int |
lept.pixThresholdPixelSum(PIX pix,
int thresh,
int[] pabove,
int[] tab8) |
static int |
lept.pixThresholdPixelSum(PIX pix,
int thresh,
IntBuffer pabove,
IntBuffer tab8) |
static int |
lept.pixThresholdPixelSum(PIX pix,
int thresh,
IntPointer pabove,
IntPointer tab8) |
static int |
lept.pixThresholdSpreadNorm(PIX pixs,
int filtertype,
int edgethresh,
int smoothx,
int smoothy,
float gamma,
int minval,
int maxval,
int targetthresh,
PIX ppixth,
PIX ppixb,
PIX ppixd) |
static int |
lept.pixThresholdSpreadNorm(PIX pixs,
int filtertype,
int edgethresh,
int smoothx,
int smoothy,
float gamma,
int minval,
int maxval,
int targetthresh,
PointerPointer ppixth,
PointerPointer ppixb,
PointerPointer ppixd) |
static PIX |
lept.pixThresholdTo2bpp(PIX pixs,
int nlevels,
int cmapflag) |
static PIX |
lept.pixThresholdTo4bpp(PIX pixs,
int nlevels,
int cmapflag) |
static PIX |
lept.pixThresholdToBinary(PIX pixs,
int thresh) |
static PIX |
lept.pixThresholdToValue(PIX pixd,
PIX pixs,
int threshval,
int setval) |
static PIX |
lept.pixThreshOnDoubleNorm(PIX pixs,
int mindiff) |
static PIXTILING |
lept.pixTilingCreate(PIX pixs,
int nx,
int ny,
int w,
int h,
int xoverlap,
int yoverlap) |
static int |
lept.pixTilingPaintTile(PIX pixd,
int i,
int j,
PIX pixs,
PIXTILING pt) |
static PIX |
lept.pixTophat(PIX pixs,
int hsize,
int vsize,
int type) |
static int |
lept.pixTransferAllData(PIX pixd,
PIX ppixs,
int copytext,
int copyformat) |
static int |
lept.pixTransferAllData(PIX pixd,
PointerPointer ppixs,
int copytext,
int copyformat) |
static PIX |
lept.pixTranslate(PIX pixd,
PIX pixs,
int hshift,
int vshift,
int incolor) |
static int |
lept.pixTRCMap(PIX pixs,
PIX pixm,
NUMA na) |
static int |
lept.pixTRCMapGeneral(PIX pixs,
PIX pixm,
NUMA nar,
NUMA nag,
NUMA nab) |
static PIX |
lept.pixTwoSidedEdgeFilter(PIX pixs,
int orientflag) |
static PIX |
lept.pixUnionOfMorphOps(PIX pixs,
SELA sela,
int type) |
static PIX |
lept.pixUnpackBinary(PIX pixs,
int depth,
int invert) |
static PIX |
lept.pixUnsharpMasking(PIX pixs,
int halfwidth,
float fract) |
static PIX |
lept.pixUnsharpMaskingFast(PIX pixs,
int halfwidth,
float fract,
int direction) |
static PIX |
lept.pixUnsharpMaskingGray(PIX pixs,
int halfwidth,
float fract) |
static PIX |
lept.pixUnsharpMaskingGray1D(PIX pixs,
int halfwidth,
float fract,
int direction) |
static PIX |
lept.pixUnsharpMaskingGray2D(PIX pixs,
int halfwidth,
float fract) |
static PIX |
lept.pixUnsharpMaskingGrayFast(PIX pixs,
int halfwidth,
float fract,
int direction) |
static int |
lept.pixUpDownDetect(PIX pixs,
float[] pconf,
int mincount,
int npixels,
int debug) |
static int |
lept.pixUpDownDetect(PIX pixs,
FloatBuffer pconf,
int mincount,
int npixels,
int debug) |
static int |
lept.pixUpDownDetect(PIX pixs,
FloatPointer pconf,
int mincount,
int npixels,
int debug) |
static int |
lept.pixUsesCmapColor(PIX pixs,
int[] pcolor) |
static int |
lept.pixUsesCmapColor(PIX pixs,
IntBuffer pcolor) |
static int |
lept.pixUsesCmapColor(PIX pixs,
IntPointer pcolor) |
static NUMA |
lept.pixVarianceByColumn(PIX pix,
BOX box) |
static NUMA |
lept.pixVarianceByRow(PIX pix,
BOX box) |
static int |
lept.pixVarianceInRect(PIX pix,
BOX box,
float[] prootvar) |
static int |
lept.pixVarianceInRect(PIX pix,
BOX box,
FloatBuffer prootvar) |
static int |
lept.pixVarianceInRect(PIX pix,
BOX box,
FloatPointer prootvar) |
static int |
lept.pixVarianceInRectangle(PIX pixs,
BOX box,
PIX pix_ma,
DPIX dpix_msa,
float[] pvar,
float[] prvar) |
static int |
lept.pixVarianceInRectangle(PIX pixs,
BOX box,
PIX pix_ma,
DPIX dpix_msa,
FloatBuffer pvar,
FloatBuffer prvar) |
static int |
lept.pixVarianceInRectangle(PIX pixs,
BOX box,
PIX pix_ma,
DPIX dpix_msa,
FloatPointer pvar,
FloatPointer prvar) |
static PIX |
lept.pixVarThresholdToBinary(PIX pixs,
PIX pixg) |
static PIX |
lept.pixVShear(PIX pixd,
PIX pixs,
int xloc,
float radang,
int incolor) |
static PIX |
lept.pixVShearCenter(PIX pixd,
PIX pixs,
float radang,
int incolor) |
static PIX |
lept.pixVShearCorner(PIX pixd,
PIX pixs,
float radang,
int incolor) |
static int |
lept.pixVShearIP(PIX pixs,
int xloc,
float radang,
int incolor) |
static PIX |
lept.pixVShearLI(PIX pixs,
int xloc,
float radang,
int incolor) |
static PIX |
lept.pixWarpStereoscopic(PIX pixs,
int zbend,
int zshiftt,
int zshiftb,
int ybendt,
int ybendb,
int redleft) |
static PIX |
lept.pixWindowedMean(PIX pixs,
int wc,
int hc,
int hasborder,
int normflag) |
static PIX |
lept.pixWindowedMeanSquare(PIX pixs,
int wc,
int hc,
int hasborder) |
static int |
lept.pixWindowedStats(PIX pixs,
int wc,
int hc,
int hasborder,
PIX ppixm,
PIX ppixms,
FPIX pfpixv,
FPIX pfpixrv) |
static int |
lept.pixWindowedStats(PIX pixs,
int wc,
int hc,
int hasborder,
PointerPointer ppixm,
PointerPointer ppixms,
PointerPointer pfpixv,
PointerPointer pfpixrv) |
static int |
lept.pixWindowedVariance(PIX pixm,
PIX pixms,
FPIX pfpixv,
FPIX pfpixrv) |
static int |
lept.pixWindowedVariance(PIX pixm,
PIX pixms,
PointerPointer pfpixv,
PointerPointer pfpixrv) |
static int |
lept.pixWindowedVarianceOnLine(PIX pixs,
int dir,
int loc,
int c1,
int c2,
int size,
NUMA pnad) |
static int |
lept.pixWindowedVarianceOnLine(PIX pixs,
int dir,
int loc,
int c1,
int c2,
int size,
PointerPointer pnad) |
static int |
lept.pixWordBoxesByDilation(PIX pixs,
int minwidth,
int minheight,
int maxwidth,
int maxheight,
BOXA pboxa,
int[] psize,
PIXA pixadb) |
static int |
lept.pixWordBoxesByDilation(PIX pixs,
int minwidth,
int minheight,
int maxwidth,
int maxheight,
BOXA pboxa,
IntBuffer psize,
PIXA pixadb) |
static int |
lept.pixWordBoxesByDilation(PIX pixs,
int minwidth,
int minheight,
int maxwidth,
int maxheight,
BOXA pboxa,
IntPointer psize,
PIXA pixadb) |
static int |
lept.pixWordBoxesByDilation(PIX pixs,
int minwidth,
int minheight,
int maxwidth,
int maxheight,
PointerPointer pboxa,
IntPointer psize,
PIXA pixadb) |
static int |
lept.pixWordMaskByDilation(PIX pixs,
PIX ppixm,
int[] psize,
PIXA pixadb) |
static int |
lept.pixWordMaskByDilation(PIX pixs,
PIX ppixm,
IntBuffer psize,
PIXA pixadb) |
static int |
lept.pixWordMaskByDilation(PIX pixs,
PIX ppixm,
IntPointer psize,
PIXA pixadb) |
static int |
lept.pixWordMaskByDilation(PIX pixs,
PointerPointer ppixm,
IntPointer psize,
PIXA pixadb) |
static int |
lept.pixWrite(BytePointer fname,
PIX pix,
int format) |
static int |
lept.pixWrite(String fname,
PIX pix,
int format) |
static int |
lept.pixWriteAutoFormat(BytePointer filename,
PIX pix) |
static int |
lept.pixWriteAutoFormat(String filename,
PIX pix) |
static int |
lept.pixWriteCompressedToPS(PIX pix,
BytePointer fileout,
int res,
int level,
int[] pindex) |
static int |
lept.pixWriteCompressedToPS(PIX pix,
BytePointer fileout,
int res,
int level,
IntBuffer pindex) |
static int |
lept.pixWriteCompressedToPS(PIX pix,
BytePointer fileout,
int res,
int level,
IntPointer pindex) |
static int |
lept.pixWriteCompressedToPS(PIX pix,
String fileout,
int res,
int level,
int[] pindex) |
static int |
lept.pixWriteCompressedToPS(PIX pix,
String fileout,
int res,
int level,
IntBuffer pindex) |
static int |
lept.pixWriteCompressedToPS(PIX pix,
String fileout,
int res,
int level,
IntPointer pindex) |
static int |
lept.pixWriteDebug(BytePointer fname,
PIX pix,
int format) |
static int |
lept.pixWriteDebug(String fname,
PIX pix,
int format) |
static int |
lept.pixWriteImpliedFormat(BytePointer filename,
PIX pix,
int quality,
int progressive) |
static int |
lept.pixWriteImpliedFormat(String filename,
PIX pix,
int quality,
int progressive) |
static int |
lept.pixWriteJp2k(BytePointer filename,
PIX pix,
int quality,
int nlevels,
int hint,
int debug) |
static int |
lept.pixWriteJp2k(String filename,
PIX pix,
int quality,
int nlevels,
int hint,
int debug) |
static int |
lept.pixWriteJpeg(BytePointer filename,
PIX pix,
int quality,
int progressive) |
static int |
lept.pixWriteJpeg(String filename,
PIX pix,
int quality,
int progressive) |
static int |
lept.pixWriteMem(byte[] pdata,
SizeTPointer psize,
PIX pix,
int format) |
static int |
lept.pixWriteMem(ByteBuffer pdata,
SizeTPointer psize,
PIX pix,
int format) |
static int |
lept.pixWriteMem(BytePointer pdata,
SizeTPointer psize,
PIX pix,
int format) |
static int |
lept.pixWriteMem(PointerPointer pdata,
SizeTPointer psize,
PIX pix,
int format) |
static int |
lept.pixWriteMemBmp(byte[] pfdata,
SizeTPointer pfsize,
PIX pixs) |
static int |
lept.pixWriteMemBmp(ByteBuffer pfdata,
SizeTPointer pfsize,
PIX pixs) |
static int |
lept.pixWriteMemBmp(BytePointer pfdata,
SizeTPointer pfsize,
PIX pixs) |
static int |
lept.pixWriteMemBmp(PointerPointer pfdata,
SizeTPointer pfsize,
PIX pixs) |
static int |
lept.pixWriteMemGif(byte[] pdata,
SizeTPointer psize,
PIX pix) |
static int |
lept.pixWriteMemGif(ByteBuffer pdata,
SizeTPointer psize,
PIX pix) |
static int |
lept.pixWriteMemGif(BytePointer pdata,
SizeTPointer psize,
PIX pix) |
static int |
lept.pixWriteMemGif(PointerPointer pdata,
SizeTPointer psize,
PIX pix) |
static int |
lept.pixWriteMemJp2k(byte[] pdata,
SizeTPointer psize,
PIX pix,
int quality,
int nlevels,
int hint,
int debug) |
static int |
lept.pixWriteMemJp2k(ByteBuffer pdata,
SizeTPointer psize,
PIX pix,
int quality,
int nlevels,
int hint,
int debug) |
static int |
lept.pixWriteMemJp2k(BytePointer pdata,
SizeTPointer psize,
PIX pix,
int quality,
int nlevels,
int hint,
int debug) |
static int |
lept.pixWriteMemJp2k(PointerPointer pdata,
SizeTPointer psize,
PIX pix,
int quality,
int nlevels,
int hint,
int debug) |
static int |
lept.pixWriteMemJpeg(byte[] pdata,
SizeTPointer psize,
PIX pix,
int quality,
int progressive) |
static int |
lept.pixWriteMemJpeg(ByteBuffer pdata,
SizeTPointer psize,
PIX pix,
int quality,
int progressive) |
static int |
lept.pixWriteMemJpeg(BytePointer pdata,
SizeTPointer psize,
PIX pix,
int quality,
int progressive) |
static int |
lept.pixWriteMemJpeg(PointerPointer pdata,
SizeTPointer psize,
PIX pix,
int quality,
int progressive) |
static int |
lept.pixWriteMemPam(byte[] pdata,
SizeTPointer psize,
PIX pix) |
static int |
lept.pixWriteMemPam(ByteBuffer pdata,
SizeTPointer psize,
PIX pix) |
static int |
lept.pixWriteMemPam(BytePointer pdata,
SizeTPointer psize,
PIX pix) |
static int |
lept.pixWriteMemPam(PointerPointer pdata,
SizeTPointer psize,
PIX pix) |
static int |
lept.pixWriteMemPdf(byte[] pdata,
SizeTPointer pnbytes,
PIX pix,
int res,
BytePointer title) |
static int |
lept.pixWriteMemPdf(byte[] pdata,
SizeTPointer pnbytes,
PIX pix,
int res,
String title) |
static int |
lept.pixWriteMemPdf(ByteBuffer pdata,
SizeTPointer pnbytes,
PIX pix,
int res,
BytePointer title) |
static int |
lept.pixWriteMemPdf(ByteBuffer pdata,
SizeTPointer pnbytes,
PIX pix,
int res,
String title) |
static int |
lept.pixWriteMemPdf(BytePointer pdata,
SizeTPointer pnbytes,
PIX pix,
int res,
BytePointer title) |
static int |
lept.pixWriteMemPdf(BytePointer pdata,
SizeTPointer pnbytes,
PIX pix,
int res,
String title) |
static int |
lept.pixWriteMemPdf(PointerPointer pdata,
SizeTPointer pnbytes,
PIX pix,
int res,
BytePointer title) |
static int |
lept.pixWriteMemPng(byte[] pfiledata,
SizeTPointer pfilesize,
PIX pix,
float gamma) |
static int |
lept.pixWriteMemPng(ByteBuffer pfiledata,
SizeTPointer pfilesize,
PIX pix,
float gamma) |
static int |
lept.pixWriteMemPng(BytePointer pfiledata,
SizeTPointer pfilesize,
PIX pix,
float gamma) |
static int |
lept.pixWriteMemPng(PointerPointer pfiledata,
SizeTPointer pfilesize,
PIX pix,
float gamma) |
static int |
lept.pixWriteMemPnm(byte[] pdata,
SizeTPointer psize,
PIX pix) |
static int |
lept.pixWriteMemPnm(ByteBuffer pdata,
SizeTPointer psize,
PIX pix) |
static int |
lept.pixWriteMemPnm(BytePointer pdata,
SizeTPointer psize,
PIX pix) |
static int |
lept.pixWriteMemPnm(PointerPointer pdata,
SizeTPointer psize,
PIX pix) |
static int |
lept.pixWriteMemPS(byte[] pdata,
SizeTPointer psize,
PIX pix,
BOX box,
int res,
float scale) |
static int |
lept.pixWriteMemPS(ByteBuffer pdata,
SizeTPointer psize,
PIX pix,
BOX box,
int res,
float scale) |
static int |
lept.pixWriteMemPS(BytePointer pdata,
SizeTPointer psize,
PIX pix,
BOX box,
int res,
float scale) |
static int |
lept.pixWriteMemPS(PointerPointer pdata,
SizeTPointer psize,
PIX pix,
BOX box,
int res,
float scale) |
static int |
lept.pixWriteMemSpix(byte[] pdata,
SizeTPointer psize,
PIX pix) |
static int |
lept.pixWriteMemSpix(ByteBuffer pdata,
SizeTPointer psize,
PIX pix) |
static int |
lept.pixWriteMemSpix(BytePointer pdata,
SizeTPointer psize,
PIX pix) |
static int |
lept.pixWriteMemSpix(PointerPointer pdata,
SizeTPointer psize,
PIX pix) |
static int |
lept.pixWriteMemTiff(byte[] pdata,
SizeTPointer psize,
PIX pix,
int comptype) |
static int |
lept.pixWriteMemTiff(ByteBuffer pdata,
SizeTPointer psize,
PIX pix,
int comptype) |
static int |
lept.pixWriteMemTiff(BytePointer pdata,
SizeTPointer psize,
PIX pix,
int comptype) |
static int |
lept.pixWriteMemTiff(PointerPointer pdata,
SizeTPointer psize,
PIX pix,
int comptype) |
static int |
lept.pixWriteMemTiffCustom(byte[] pdata,
SizeTPointer psize,
PIX pix,
int comptype,
NUMA natags,
SARRAY savals,
SARRAY satypes,
NUMA nasizes) |
static int |
lept.pixWriteMemTiffCustom(ByteBuffer pdata,
SizeTPointer psize,
PIX pix,
int comptype,
NUMA natags,
SARRAY savals,
SARRAY satypes,
NUMA nasizes) |
static int |
lept.pixWriteMemTiffCustom(BytePointer pdata,
SizeTPointer psize,
PIX pix,
int comptype,
NUMA natags,
SARRAY savals,
SARRAY satypes,
NUMA nasizes) |
static int |
lept.pixWriteMemTiffCustom(PointerPointer pdata,
SizeTPointer psize,
PIX pix,
int comptype,
NUMA natags,
SARRAY savals,
SARRAY satypes,
NUMA nasizes) |
static int |
lept.pixWriteMemWebP(byte[] pencdata,
SizeTPointer pencsize,
PIX pixs,
int quality,
int lossless) |
static int |
lept.pixWriteMemWebP(ByteBuffer pencdata,
SizeTPointer pencsize,
PIX pixs,
int quality,
int lossless) |
static int |
lept.pixWriteMemWebP(BytePointer pencdata,
SizeTPointer pencsize,
PIX pixs,
int quality,
int lossless) |
static int |
lept.pixWriteMemWebP(PointerPointer pencdata,
SizeTPointer pencsize,
PIX pixs,
int quality,
int lossless) |
static int |
lept.pixWriteMixedToPS(PIX pixb,
PIX pixc,
float scale,
int pageno,
BytePointer fileout) |
static int |
lept.pixWriteMixedToPS(PIX pixb,
PIX pixc,
float scale,
int pageno,
String fileout) |
static int |
lept.pixWritePng(BytePointer filename,
PIX pix,
float gamma) |
static int |
lept.pixWritePng(String filename,
PIX pix,
float gamma) |
static int |
lept.pixWriteSegmentedPageToPS(PIX pixs,
PIX pixm,
float textscale,
float imagescale,
int threshold,
int pageno,
BytePointer fileout) |
static int |
lept.pixWriteSegmentedPageToPS(PIX pixs,
PIX pixm,
float textscale,
float imagescale,
int threshold,
int pageno,
String fileout) |
static int |
lept.pixWriteStream(Pointer fp,
PIX pix,
int format) |
static int |
lept.pixWriteStreamAsciiPnm(Pointer fp,
PIX pix) |
static int |
lept.pixWriteStreamBmp(Pointer fp,
PIX pix) |
static int |
lept.pixWriteStreamGif(Pointer fp,
PIX pix) |
static int |
lept.pixWriteStreamJp2k(Pointer fp,
PIX pix,
int quality,
int nlevels,
int codec,
int hint,
int debug) |
static int |
lept.pixWriteStreamJpeg(Pointer fp,
PIX pixs,
int quality,
int progressive) |
static int |
lept.pixWriteStreamPam(Pointer fp,
PIX pix) |
static int |
lept.pixWriteStreamPdf(Pointer fp,
PIX pix,
int res,
BytePointer title) |
static int |
lept.pixWriteStreamPdf(Pointer fp,
PIX pix,
int res,
String title) |
static int |
lept.pixWriteStreamPng(Pointer fp,
PIX pix,
float gamma) |
static int |
lept.pixWriteStreamPnm(Pointer fp,
PIX pix) |
static int |
lept.pixWriteStreamPS(Pointer fp,
PIX pix,
BOX box,
int res,
float scale) |
static int |
lept.pixWriteStreamSpix(Pointer fp,
PIX pix) |
static int |
lept.pixWriteStreamTiff(Pointer fp,
PIX pix,
int comptype) |
static int |
lept.pixWriteStreamTiffWA(Pointer fp,
PIX pix,
int comptype,
BytePointer modestr) |
static int |
lept.pixWriteStreamTiffWA(Pointer fp,
PIX pix,
int comptype,
String modestr) |
static int |
lept.pixWriteStreamWebP(Pointer fp,
PIX pixs,
int quality,
int lossless) |
static BytePointer |
lept.pixWriteStringPS(PIX pixs,
BOX box,
int res,
float scale) |
static int |
lept.pixWriteTiff(BytePointer filename,
PIX pix,
int comptype,
BytePointer modestr) |
static int |
lept.pixWriteTiff(String filename,
PIX pix,
int comptype,
String modestr) |
static int |
lept.pixWriteTiffCustom(BytePointer filename,
PIX pix,
int comptype,
BytePointer modestr,
NUMA natags,
SARRAY savals,
SARRAY satypes,
NUMA nasizes) |
static int |
lept.pixWriteTiffCustom(String filename,
PIX pix,
int comptype,
String modestr,
NUMA natags,
SARRAY savals,
SARRAY satypes,
NUMA nasizes) |
static int |
lept.pixWriteWebP(BytePointer filename,
PIX pixs,
int quality,
int lossless) |
static int |
lept.pixWriteWebP(String filename,
PIX pixs,
int quality,
int lossless) |
static PIX |
lept.pixXor(PIX pixd,
PIX pixs1,
PIX pixs2) |
static int |
lept.pixZero(PIX pix,
int[] pempty) |
static int |
lept.pixZero(PIX pix,
IntBuffer pempty) |
static int |
lept.pixZero(PIX pix,
IntPointer pempty) |
static PTAA |
lept.ptaaGetBoundaryPixels(PIX pixs,
int type,
int connectivity,
BOXA pboxa,
PIXA ppixa) |
static PTAA |
lept.ptaaGetBoundaryPixels(PIX pixs,
int type,
int connectivity,
PointerPointer pboxa,
PointerPointer ppixa) |
static PTAA |
lept.ptaaIndexLabeledPixels(PIX pixs,
int[] pncc) |
static PTAA |
lept.ptaaIndexLabeledPixels(PIX pixs,
IntBuffer pncc) |
static PTAA |
lept.ptaaIndexLabeledPixels(PIX pixs,
IntPointer pncc) |
static PTA |
lept.ptaCropToMask(PTA ptas,
PIX pixm) |
static PTA |
lept.ptaGetBoundaryPixels(PIX pixs,
int type) |
static PTA |
lept.ptaGetNeighborPixLocs(PIX pixs,
int x,
int y,
int conn) |
static PTA |
lept.ptaGetPixelsFromPix(PIX pixs,
BOX box) |
static PTA |
lept.ptaReplicatePattern(PTA ptas,
PIX pixp,
PTA ptap,
int cx,
int cy,
int w,
int h) |
static int |
lept.recogAddSample(L_RECOG recog,
PIX pix,
int debug) |
static int |
lept.recogCorrelationBestChar(L_RECOG recog,
PIX pixs,
BOX pbox,
float[] pscore,
int[] pindex,
byte[] pcharstr,
PIX ppixdb) |
static int |
lept.recogCorrelationBestChar(L_RECOG recog,
PIX pixs,
BOX pbox,
FloatBuffer pscore,
IntBuffer pindex,
ByteBuffer pcharstr,
PIX ppixdb) |
static int |
lept.recogCorrelationBestChar(L_RECOG recog,
PIX pixs,
BOX pbox,
FloatPointer pscore,
IntPointer pindex,
BytePointer pcharstr,
PIX ppixdb) |
static int |
lept.recogCorrelationBestChar(L_RECOG recog,
PIX pixs,
PointerPointer pbox,
FloatPointer pscore,
IntPointer pindex,
PointerPointer pcharstr,
PointerPointer ppixdb) |
static int |
lept.recogCorrelationBestRow(L_RECOG recog,
PIX pixs,
BOXA pboxa,
NUMA pnascore,
NUMA pnaindex,
SARRAY psachar,
int debug) |
static int |
lept.recogCorrelationBestRow(L_RECOG recog,
PIX pixs,
PointerPointer pboxa,
PointerPointer pnascore,
PointerPointer pnaindex,
PointerPointer psachar,
int debug) |
static int |
lept.recogCreateDid(L_RECOG recog,
PIX pixs) |
static BOXA |
lept.recogDecode(L_RECOG recog,
PIX pixs,
int nlevels,
PIX ppixdb) |
static BOXA |
lept.recogDecode(L_RECOG recog,
PIX pixs,
int nlevels,
PointerPointer ppixdb) |
static int |
lept.recogIdentifyMultiple(L_RECOG recog,
PIX pixs,
int minh,
int skipsplit,
BOXA pboxa,
PIXA ppixa,
PIX ppixdb,
int debugsplit) |
static int |
lept.recogIdentifyMultiple(L_RECOG recog,
PIX pixs,
int minh,
int skipsplit,
PointerPointer pboxa,
PointerPointer ppixa,
PointerPointer ppixdb,
int debugsplit) |
static int |
lept.recogIdentifyPix(L_RECOG recog,
PIX pixs,
PIX ppixdb) |
static int |
lept.recogIdentifyPix(L_RECOG recog,
PIX pixs,
PointerPointer ppixdb) |
static int |
lept.recogIdentifyPixa(L_RECOG recog,
PIXA pixa,
PIX ppixdb) |
static PIX |
lept.recogModifyTemplate(L_RECOG recog,
PIX pixs) |
static int |
lept.recogProcessLabeled(L_RECOG recog,
PIX pixs,
BOX box,
byte[] text,
PIX ppix) |
static int |
lept.recogProcessLabeled(L_RECOG recog,
PIX pixs,
BOX box,
ByteBuffer text,
PIX ppix) |
static int |
lept.recogProcessLabeled(L_RECOG recog,
PIX pixs,
BOX box,
BytePointer text,
PIX ppix) |
static int |
lept.recogProcessLabeled(L_RECOG recog,
PIX pixs,
BOX box,
BytePointer text,
PointerPointer ppix) |
static PIX |
lept.recogProcessToIdentify(L_RECOG recog,
PIX pixs,
int pad) |
static int |
lept.recogRemoveOutliers1(L_RECOG precog,
float minscore,
int mintarget,
int minsize,
PIX ppixsave,
PIX ppixrem) |
static int |
lept.recogRemoveOutliers2(L_RECOG precog,
float minscore,
int minsize,
PIX ppixsave,
PIX ppixrem) |
static PIX |
lept.recogShowMatch(L_RECOG recog,
PIX pix1,
PIX pix2,
BOX box,
int index,
float score) |
static int |
lept.recogSplitIntoCharacters(L_RECOG recog,
PIX pixs,
int minh,
int skipsplit,
BOXA pboxa,
PIXA ppixa,
int debug) |
static int |
lept.recogSplitIntoCharacters(L_RECOG recog,
PIX pixs,
int minh,
int skipsplit,
PointerPointer pboxa,
PointerPointer ppixa,
int debug) |
static int |
lept.recogTrainLabeled(L_RECOG recog,
PIX pixs,
BOX box,
byte[] text,
int debug) |
static int |
lept.recogTrainLabeled(L_RECOG recog,
PIX pixs,
BOX box,
ByteBuffer text,
int debug) |
static int |
lept.recogTrainLabeled(L_RECOG recog,
PIX pixs,
BOX box,
BytePointer text,
int debug) |
static int |
lept.regTestComparePix(L_REGPARAMS rp,
PIX pix1,
PIX pix2) |
static int |
lept.regTestCompareSimilarPix(L_REGPARAMS rp,
PIX pix1,
PIX pix2,
int mindiff,
float maxfract,
int printstats) |
static int |
lept.regTestWritePixAndCheck(L_REGPARAMS rp,
PIX pix,
int format) |
static SEL |
lept.selCreateFromColorPix(PIX pixs,
BytePointer selname) |
static SEL |
lept.selCreateFromColorPix(PIX pixs,
String selname) |
static SEL |
lept.selCreateFromPix(PIX pix,
int cy,
int cx,
BytePointer name) |
static SEL |
lept.selCreateFromPix(PIX pix,
int cy,
int cx,
String name) |
static int |
lept.selectDefaultPdfEncoding(PIX pix,
int[] ptype) |
static int |
lept.selectDefaultPdfEncoding(PIX pix,
IntBuffer ptype) |
static int |
lept.selectDefaultPdfEncoding(PIX pix,
IntPointer ptype) |
static PIXA |
lept.showExtractNumbers(PIX pixs,
SARRAY sa,
BOXAA baa,
NUMAA naa,
PIX ppixdb) |
static PIXA |
lept.showExtractNumbers(PIX pixs,
SARRAY sa,
BOXAA baa,
NUMAA naa,
PointerPointer ppixdb) |
static L_WSHED |
lept.wshedCreate(PIX pixs,
PIX pixm,
int mindepth,
int debugflag) |
Copyright © 2021. All rights reserved.