Interface Leptonica

All Superinterfaces:
ILeptonica, com.sun.jna.Library

public interface Leptonica extends com.sun.jna.Library, ILeptonica
JNA Wrapper for Leptonica Image Processing Library using JNA Interface Mapping.
  • Field Details

  • Method Details

    • pixCleanBackgroundToWhite

      Pix pixCleanBackgroundToWhite(Pix pixs, Pix pixim, Pix pixg, float gamma, int blackval, int whiteval)
      Original signature : PIX* pixCleanBackgroundToWhite(PIX*, PIX*, PIX*, l_float32, l_int32, l_int32)
    • pixBackgroundNormSimple

      Pix pixBackgroundNormSimple(Pix pixs, Pix pixim, Pix pixg)
      Original signature : PIX* pixBackgroundNormSimple(PIX*, PIX*, PIX*)
    • pixBackgroundNorm

      Pix pixBackgroundNorm(Pix pixs, Pix pixim, Pix pixg, int sx, int sy, int thresh, int mincount, int bgval, int smoothx, int smoothy)
      Original signature : PIX* pixBackgroundNorm(PIX*, PIX*, PIX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixBackgroundNormMorph

      Pix pixBackgroundNormMorph(Pix pixs, Pix pixim, int reduction, int size, int bgval)
      Original signature : PIX* pixBackgroundNormMorph(PIX*, PIX*, l_int32, l_int32, l_int32)
    • pixBackgroundNormGrayArray

      int pixBackgroundNormGrayArray(Pix pixs, Pix pixim, int sx, int sy, int thresh, int mincount, int bgval, int smoothx, int smoothy, com.sun.jna.ptr.PointerByReference ppixd)
      Original signature : l_ok pixBackgroundNormGrayArray(PIX*, PIX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, PIX**)
    • pixBackgroundNormRGBArrays

      int pixBackgroundNormRGBArrays(Pix pixs, Pix pixim, Pix pixg, int sx, int sy, int thresh, int mincount, int bgval, int smoothx, int smoothy, com.sun.jna.ptr.PointerByReference ppixr, com.sun.jna.ptr.PointerByReference ppixg, com.sun.jna.ptr.PointerByReference ppixb)
      Original signature : l_ok pixBackgroundNormRGBArrays(PIX*, PIX*, PIX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, PIX**, PIX**, PIX**)
    • pixBackgroundNormGrayArrayMorph

      int pixBackgroundNormGrayArrayMorph(Pix pixs, Pix pixim, int reduction, int size, int bgval, com.sun.jna.ptr.PointerByReference ppixd)
      Original signature : l_ok pixBackgroundNormGrayArrayMorph(PIX*, PIX*, l_int32, l_int32, l_int32, PIX**)
    • pixBackgroundNormRGBArraysMorph

      int pixBackgroundNormRGBArraysMorph(Pix pixs, Pix pixim, int reduction, int size, int bgval, com.sun.jna.ptr.PointerByReference ppixr, com.sun.jna.ptr.PointerByReference ppixg, com.sun.jna.ptr.PointerByReference ppixb)
      Original signature : l_ok pixBackgroundNormRGBArraysMorph(PIX*, PIX*, l_int32, l_int32, l_int32, PIX**, PIX**, PIX**)
    • pixGetBackgroundGrayMap

      int pixGetBackgroundGrayMap(Pix pixs, Pix pixim, int sx, int sy, int thresh, int mincount, com.sun.jna.ptr.PointerByReference ppixd)
      Original signature : l_ok pixGetBackgroundGrayMap(PIX*, PIX*, l_int32, l_int32, l_int32, l_int32, PIX**)
    • pixGetBackgroundRGBMap

      int pixGetBackgroundRGBMap(Pix pixs, Pix pixim, Pix pixg, int sx, int sy, int thresh, int mincount, com.sun.jna.ptr.PointerByReference ppixmr, com.sun.jna.ptr.PointerByReference ppixmg, com.sun.jna.ptr.PointerByReference ppixmb)
      Original signature : l_ok pixGetBackgroundRGBMap(PIX*, PIX*, PIX*, l_int32, l_int32, l_int32, l_int32, PIX**, PIX**, PIX**)
    • pixGetBackgroundGrayMapMorph

      int pixGetBackgroundGrayMapMorph(Pix pixs, Pix pixim, int reduction, int size, com.sun.jna.ptr.PointerByReference ppixm)
      Original signature : l_ok pixGetBackgroundGrayMapMorph(PIX*, PIX*, l_int32, l_int32, PIX**)
    • pixGetBackgroundRGBMapMorph

      int pixGetBackgroundRGBMapMorph(Pix pixs, Pix pixim, int reduction, int size, com.sun.jna.ptr.PointerByReference ppixmr, com.sun.jna.ptr.PointerByReference ppixmg, com.sun.jna.ptr.PointerByReference ppixmb)
      Original signature : l_ok pixGetBackgroundRGBMapMorph(PIX*, PIX*, l_int32, l_int32, PIX**, PIX**, PIX**)
    • pixFillMapHoles

      int pixFillMapHoles(Pix pix, int nx, int ny, int filltype)
      Original signature : l_ok pixFillMapHoles(PIX*, l_int32, l_int32, l_int32)
    • pixExtendByReplication

      Pix pixExtendByReplication(Pix pixs, int addw, int addh)
      Original signature : PIX* pixExtendByReplication(PIX*, l_int32, l_int32)
    • pixSmoothConnectedRegions

      int pixSmoothConnectedRegions(Pix pixs, Pix pixm, int factor)
      Original signature : l_ok pixSmoothConnectedRegions(PIX*, PIX*, l_int32)
    • pixGetInvBackgroundMap

      Pix pixGetInvBackgroundMap(Pix pixs, int bgval, int smoothx, int smoothy)
      Original signature : PIX* pixGetInvBackgroundMap(PIX*, l_int32, l_int32, l_int32)
    • pixApplyInvBackgroundGrayMap

      Pix pixApplyInvBackgroundGrayMap(Pix pixs, Pix pixm, int sx, int sy)
      Original signature : PIX* pixApplyInvBackgroundGrayMap(PIX*, PIX*, l_int32, l_int32)
    • pixApplyInvBackgroundRGBMap

      Pix pixApplyInvBackgroundRGBMap(Pix pixs, Pix pixmr, Pix pixmg, Pix pixmb, int sx, int sy)
      Original signature : PIX* pixApplyInvBackgroundRGBMap(PIX*, PIX*, PIX*, PIX*, l_int32, l_int32)
    • pixApplyVariableGrayMap

      Pix pixApplyVariableGrayMap(Pix pixs, Pix pixg, int target)
      Original signature : PIX* pixApplyVariableGrayMap(PIX*, PIX*, l_int32)
    • pixGlobalNormRGB

      Pix pixGlobalNormRGB(Pix pixd, Pix pixs, int rval, int gval, int bval, int mapval)
      Original signature : PIX* pixGlobalNormRGB(PIX*, PIX*, l_int32, l_int32, l_int32, l_int32)
    • pixGlobalNormNoSatRGB

      Pix pixGlobalNormNoSatRGB(Pix pixd, Pix pixs, int rval, int gval, int bval, int factor, float rank)
      Original signature : PIX* pixGlobalNormNoSatRGB(PIX*, PIX*, l_int32, l_int32, l_int32, l_int32, l_float32)
    • pixThresholdSpreadNorm

      int pixThresholdSpreadNorm(Pix pixs, int filtertype, int edgethresh, int smoothx, int smoothy, float gamma, int minval, int maxval, int targetthresh, com.sun.jna.ptr.PointerByReference ppixth, com.sun.jna.ptr.PointerByReference ppixb, com.sun.jna.ptr.PointerByReference ppixd)
      Original signature : l_ok pixThresholdSpreadNorm(PIX*, l_int32, l_int32, l_int32, l_int32, l_float32, l_int32, l_int32, l_int32, PIX**, PIX**, PIX**)
    • pixBackgroundNormFlex

      Pix pixBackgroundNormFlex(Pix pixs, int sx, int sy, int smoothx, int smoothy, int delta)
      Original signature : PIX* pixBackgroundNormFlex(PIX*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixContrastNorm

      Pix pixContrastNorm(Pix pixd, Pix pixs, int sx, int sy, int mindiff, int smoothx, int smoothy)
      Original signature : PIX* pixContrastNorm(PIX*, PIX*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixAffineSampledPta

      Pix pixAffineSampledPta(Pix pixs, Pta ptad, Pta ptas, int incolor)
      Original signature : PIX* pixAffineSampledPta(PIX*, PTA*, PTA*, l_int32)
    • pixAffineSampled

      Pix pixAffineSampled(Pix pixs, FloatBuffer vc, int incolor)
      Original signature : PIX* pixAffineSampled(PIX*, l_float32*, l_int32)
    • pixAffinePta

      Pix pixAffinePta(Pix pixs, Pta ptad, Pta ptas, int incolor)
      Original signature : PIX* pixAffinePta(PIX*, PTA*, PTA*, l_int32)
    • pixAffine

      Pix pixAffine(Pix pixs, FloatBuffer vc, int incolor)
      Original signature : PIX* pixAffine(PIX*, l_float32*, l_int32)
    • pixAffinePtaColor

      Pix pixAffinePtaColor(Pix pixs, Pta ptad, Pta ptas, int colorval)
      Original signature : PIX* pixAffinePtaColor(PIX*, PTA*, PTA*, l_uint32)
    • pixAffineColor

      Pix pixAffineColor(Pix pixs, FloatBuffer vc, int colorval)
      Original signature : PIX* pixAffineColor(PIX*, l_float32*, l_uint32)
    • pixAffinePtaGray

      Pix pixAffinePtaGray(Pix pixs, Pta ptad, Pta ptas, byte grayval)
      Original signature : PIX* pixAffinePtaGray(PIX*, PTA*, PTA*, l_uint8)
    • pixAffineGray

      Pix pixAffineGray(Pix pixs, FloatBuffer vc, byte grayval)
      Original signature : PIX* pixAffineGray(PIX*, l_float32*, l_uint8)
    • pixAffinePtaWithAlpha

      Pix pixAffinePtaWithAlpha(Pix pixs, Pta ptad, Pta ptas, Pix pixg, float fract, int border)
      Original signature : PIX* pixAffinePtaWithAlpha(PIX*, PTA*, PTA*, PIX*, l_float32, l_int32)
    • ptaTranslate

      Pta ptaTranslate(Pta ptas, float transx, float transy)
      Original signature : PTA* ptaTranslate(PTA*, l_float32, l_float32)
    • ptaScale

      Pta ptaScale(Pta ptas, float scalex, float scaley)
      Original signature : PTA* ptaScale(PTA*, l_float32, l_float32)
    • ptaRotate

      Pta ptaRotate(Pta ptas, float xc, float yc, float angle)
      Original signature : PTA* ptaRotate(PTA*, l_float32, l_float32, l_float32)
    • boxaTranslate

      Boxa boxaTranslate(Boxa boxas, float transx, float transy)
      Original signature : BOXA* boxaTranslate(BOXA*, l_float32, l_float32)
    • boxaScale

      Boxa boxaScale(Boxa boxas, float scalex, float scaley)
      Original signature : BOXA* boxaScale(BOXA*, l_float32, l_float32)
    • boxaRotate

      Boxa boxaRotate(Boxa boxas, float xc, float yc, float angle)
      Original signature : BOXA* boxaRotate(BOXA*, l_float32, l_float32, l_float32)
    • ptaAffineTransform

      Pta ptaAffineTransform(Pta ptas, FloatBuffer mat)
      Original signature : PTA* ptaAffineTransform(PTA*, l_float32*)
    • boxaAffineTransform

      Boxa boxaAffineTransform(Boxa boxas, FloatBuffer mat)
      Original signature : BOXA* boxaAffineTransform(BOXA*, l_float32*)
    • pixFindBaselines

      Numa pixFindBaselines(Pix pixs, com.sun.jna.ptr.PointerByReference ppta, Pixa pixadb)
      Original signature : NUMA* pixFindBaselines(PIX*, PTA**, PIXA*)
    • pixDeskewLocal

      Pix pixDeskewLocal(Pix pixs, int nslices, int redsweep, int redsearch, float sweeprange, float sweepdelta, float minbsdelta)
      Original signature : PIX* pixDeskewLocal(PIX*, l_int32, l_int32, l_int32, l_float32, l_float32, l_float32)
    • pixGetLocalSkewTransform

      int pixGetLocalSkewTransform(Pix pixs, int nslices, int redsweep, int redsearch, float sweeprange, float sweepdelta, float minbsdelta, com.sun.jna.ptr.PointerByReference pptas, com.sun.jna.ptr.PointerByReference pptad)
      Original signature : l_ok pixGetLocalSkewTransform(PIX*, l_int32, l_int32, l_int32, l_float32, l_float32, l_float32, PTA**, PTA**)
    • pixGetLocalSkewAngles

      Numa pixGetLocalSkewAngles(Pix pixs, int nslices, int redsweep, int redsearch, float sweeprange, float sweepdelta, float minbsdelta, FloatBuffer pa, FloatBuffer pb, int debug)
      Original signature : NUMA* pixGetLocalSkewAngles(PIX*, l_int32, l_int32, l_int32, l_float32, l_float32, l_float32, l_float32*, l_float32*, l_int32)
    • bbufferCreate

      L_ByteBuffer bbufferCreate(ByteBuffer indata, int nalloc)
      Original signature : L_BBUFFER* bbufferCreate(l_uint8*, l_int32)
    • bbufferDestroy

      void bbufferDestroy(com.sun.jna.ptr.PointerByReference pbb)
      Original signature : void bbufferDestroy(L_BBUFFER**)
    • bbufferDestroyAndSaveData

      com.sun.jna.Pointer bbufferDestroyAndSaveData(com.sun.jna.ptr.PointerByReference pbb, NativeSizeByReference pnbytes)
      Original signature : l_uint8* bbufferDestroyAndSaveData(L_BBUFFER**, size_t*)
    • bbufferRead

      int bbufferRead(L_ByteBuffer bb, ByteBuffer src, int nbytes)
      Original signature : l_ok bbufferRead(L_BBUFFER*, l_uint8*, l_int32)
    • bbufferExtendArray

      int bbufferExtendArray(L_ByteBuffer bb, int nbytes)
      Original signature : l_ok bbufferExtendArray(L_BBUFFER*, l_int32)
    • bbufferWrite

      int bbufferWrite(L_ByteBuffer bb, ByteBuffer dest, NativeSize nbytes, NativeSizeByReference pnout)
      Original signature : l_ok bbufferWrite(L_BBUFFER*, l_uint8*, size_t, size_t*)
    • bbufferWriteStream

      int bbufferWriteStream(L_ByteBuffer bb, ILeptonica.FILE fp, NativeSize nbytes, NativeSizeByReference pnout)
      Original signature : l_ok bbufferWriteStream(L_BBUFFER*, FILE*, size_t, size_t*)
    • pixOtsuAdaptiveThreshold

      int pixOtsuAdaptiveThreshold(Pix pixs, int sx, int sy, int smoothx, int smoothy, float scorefract, com.sun.jna.ptr.PointerByReference ppixth, com.sun.jna.ptr.PointerByReference ppixd)
      Original signature : l_ok pixOtsuAdaptiveThreshold(PIX*, l_int32, l_int32, l_int32, l_int32, l_float32, PIX**, PIX**)
    • pixOtsuThreshOnBackgroundNorm

      Pix pixOtsuThreshOnBackgroundNorm(Pix pixs, Pix pixim, int sx, int sy, int thresh, int mincount, int bgval, int smoothx, int smoothy, float scorefract, IntBuffer pthresh)
      Original signature : PIX* pixOtsuThreshOnBackgroundNorm(PIX*, PIX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, l_float32, l_int32*)
    • pixMaskedThreshOnBackgroundNorm

      Pix pixMaskedThreshOnBackgroundNorm(Pix pixs, Pix pixim, int sx, int sy, int thresh, int mincount, int smoothx, int smoothy, float scorefract, IntBuffer pthresh)
      Original signature : PIX* pixMaskedThreshOnBackgroundNorm(PIX*, PIX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, l_float32, l_int32*)
    • pixSauvolaBinarizeTiled

      int pixSauvolaBinarizeTiled(Pix pixs, int whsize, float factor, int nx, int ny, com.sun.jna.ptr.PointerByReference ppixth, com.sun.jna.ptr.PointerByReference ppixd)
      Original signature : l_ok pixSauvolaBinarizeTiled(PIX*, l_int32, l_float32, l_int32, l_int32, PIX**, PIX**)
    • pixSauvolaBinarize

      int pixSauvolaBinarize(Pix pixs, int whsize, float factor, int addborder, com.sun.jna.ptr.PointerByReference ppixm, com.sun.jna.ptr.PointerByReference ppixsd, com.sun.jna.ptr.PointerByReference ppixth, com.sun.jna.ptr.PointerByReference ppixd)
      Original signature : l_ok pixSauvolaBinarize(PIX*, l_int32, l_float32, l_int32, PIX**, PIX**, PIX**, PIX**)
    • pixThresholdByConnComp

      int pixThresholdByConnComp(Pix pixs, Pix pixm, int start, int end, int incr, float thresh48, float threshdiff, IntBuffer pglobthresh, com.sun.jna.ptr.PointerByReference ppixd, int debugflag)
      Original signature : l_ok pixThresholdByConnComp(PIX*, PIX*, l_int32, l_int32, l_int32, l_float32, l_float32, l_int32*, PIX**, l_int32)
    • pixThresholdByConnComp

      int pixThresholdByConnComp(Pix pixs, Pix pixm, int start, int end, int incr, float thresh48, float threshdiff, com.sun.jna.ptr.IntByReference pglobthresh, com.sun.jna.ptr.PointerByReference ppixd, int debugflag)
      Original signature : l_ok pixThresholdByConnComp(PIX*, PIX*, l_int32, l_int32, l_int32, l_float32, l_float32, l_int32*, PIX**, l_int32)
    • pixExpandBinaryReplicate

      Pix pixExpandBinaryReplicate(Pix pixs, int xfact, int yfact)
      Original signature : PIX* pixExpandBinaryReplicate(PIX*, l_int32, l_int32)
    • pixExpandBinaryPower2

      Pix pixExpandBinaryPower2(Pix pixs, int factor)
      Original signature : PIX* pixExpandBinaryPower2(PIX*, l_int32)
    • pixReduceBinary2

      Pix pixReduceBinary2(Pix pixs, ByteBuffer intab)
      Original signature : PIX* pixReduceBinary2(PIX*, l_uint8*)
    • pixReduceRankBinaryCascade

      Pix pixReduceRankBinaryCascade(Pix pixs, int level1, int level2, int level3, int level4)
      Original signature : PIX* pixReduceRankBinaryCascade(PIX*, l_int32, l_int32, l_int32, l_int32)
    • pixReduceRankBinary2

      Pix pixReduceRankBinary2(Pix pixs, int level, ByteBuffer intab)
      Original signature : PIX* pixReduceRankBinary2(PIX*, l_int32, l_uint8*)
    • makeSubsampleTab2x

      com.sun.jna.Pointer makeSubsampleTab2x()
      Original signature : l_uint8* makeSubsampleTab2x()
    • pixBlend

      Pix pixBlend(Pix pixs1, Pix pixs2, int x, int y, float fract)
      Original signature : PIX* pixBlend(PIX*, PIX*, l_int32, l_int32, l_float32)
    • pixBlendMask

      Pix pixBlendMask(Pix pixd, Pix pixs1, Pix pixs2, int x, int y, float fract, int type)
      Original signature : PIX* pixBlendMask(PIX*, PIX*, PIX*, l_int32, l_int32, l_float32, l_int32)
    • pixBlendGray

      Pix pixBlendGray(Pix pixd, Pix pixs1, Pix pixs2, int x, int y, float fract, int type, int transparent, int transpix)
      Original signature : PIX* pixBlendGray(PIX*, PIX*, PIX*, l_int32, l_int32, l_float32, l_int32, l_int32, l_uint32)
    • pixBlendGrayInverse

      Pix pixBlendGrayInverse(Pix pixd, Pix pixs1, Pix pixs2, int x, int y, float fract)
      Original signature : PIX* pixBlendGrayInverse(PIX*, PIX*, PIX*, l_int32, l_int32, l_float32)
    • pixBlendColor

      Pix pixBlendColor(Pix pixd, Pix pixs1, Pix pixs2, int x, int y, float fract, int transparent, int transpix)
      Original signature : PIX* pixBlendColor(PIX*, PIX*, PIX*, l_int32, l_int32, l_float32, l_int32, l_uint32)
    • pixBlendColorByChannel

      Pix pixBlendColorByChannel(Pix pixd, Pix pixs1, Pix pixs2, int x, int y, float rfract, float gfract, float bfract, int transparent, int transpix)
      Original signature : PIX* pixBlendColorByChannel(PIX*, PIX*, PIX*, l_int32, l_int32, l_float32, l_float32, l_float32, l_int32, l_uint32)
    • pixBlendGrayAdapt

      Pix pixBlendGrayAdapt(Pix pixd, Pix pixs1, Pix pixs2, int x, int y, float fract, int shift)
      Original signature : PIX* pixBlendGrayAdapt(PIX*, PIX*, PIX*, l_int32, l_int32, l_float32, l_int32)
    • pixFadeWithGray

      Pix pixFadeWithGray(Pix pixs, Pix pixb, float factor, int type)
      Original signature : PIX* pixFadeWithGray(PIX*, PIX*, l_float32, l_int32)
    • pixBlendHardLight

      Pix pixBlendHardLight(Pix pixd, Pix pixs1, Pix pixs2, int x, int y, float fract)
      Original signature : PIX* pixBlendHardLight(PIX*, PIX*, PIX*, l_int32, l_int32, l_float32)
    • pixBlendCmap

      int pixBlendCmap(Pix pixs, Pix pixb, int x, int y, int sindex)
      Original signature : l_ok pixBlendCmap(PIX*, PIX*, l_int32, l_int32, l_int32)
    • pixBlendWithGrayMask

      Pix pixBlendWithGrayMask(Pix pixs1, Pix pixs2, Pix pixg, int x, int y)
      Original signature : PIX* pixBlendWithGrayMask(PIX*, PIX*, PIX*, l_int32, l_int32)
    • pixBlendBackgroundToColor

      Pix pixBlendBackgroundToColor(Pix pixd, Pix pixs, Box box, int color, float gamma, int minval, int maxval)
      Original signature : PIX* pixBlendBackgroundToColor(PIX*, PIX*, BOX*, l_uint32, l_float32, l_int32, l_int32)
    • pixMultiplyByColor

      Pix pixMultiplyByColor(Pix pixd, Pix pixs, Box box, int color)
      Original signature : PIX* pixMultiplyByColor(PIX*, PIX*, BOX*, l_uint32)
    • pixAlphaBlendUniform

      Pix pixAlphaBlendUniform(Pix pixs, int color)
      Original signature : PIX* pixAlphaBlendUniform(PIX*, l_uint32)
    • pixAddAlphaToBlend

      Pix pixAddAlphaToBlend(Pix pixs, float fract, int invert)
      Original signature : PIX* pixAddAlphaToBlend(PIX*, l_float32, l_int32)
    • pixSetAlphaOverWhite

      Pix pixSetAlphaOverWhite(Pix pixs)
      Original signature : PIX* pixSetAlphaOverWhite(PIX*)
    • bmfCreate

      L_Bmf bmfCreate(String dir, int fontsize)
      Original signature : L_BMF* bmfCreate(const char*, l_int32)
    • bmfDestroy

      void bmfDestroy(com.sun.jna.ptr.PointerByReference pbmf)
      Original signature : void bmfDestroy(L_BMF**)
    • bmfGetPix

      Pix bmfGetPix(L_Bmf bmf, byte chr)
      Original signature : PIX* bmfGetPix(L_BMF*, char)
    • bmfGetWidth

      int bmfGetWidth(L_Bmf bmf, byte chr, IntBuffer pw)
      Original signature : l_ok bmfGetWidth(L_BMF*, char, l_int32*)
    • bmfGetBaseline

      int bmfGetBaseline(L_Bmf bmf, byte chr, IntBuffer pbaseline)
      Original signature : l_ok bmfGetBaseline(L_BMF*, char, l_int32*)
    • pixaGetFont

      Pixa pixaGetFont(String dir, int fontsize, IntBuffer pbl0, IntBuffer pbl1, IntBuffer pbl2)
      Original signature : PIXA* pixaGetFont(const char*, l_int32, l_int32*, l_int32*, l_int32*)
    • pixaSaveFont

      int pixaSaveFont(String indir, String outdir, int fontsize)
      Original signature : l_ok pixaSaveFont(const char*, const char*, l_int32)
    • pixReadMemBmp

      Pix pixReadMemBmp(ByteBuffer cdata, NativeSize size)
      Original signature : PIX* pixReadMemBmp(const l_uint8*, size_t)
    • pixWriteMemBmp

      int pixWriteMemBmp(com.sun.jna.ptr.PointerByReference pfdata, NativeSizeByReference pfsize, Pix pixs)
      Original signature : l_ok pixWriteMemBmp(l_uint8**, size_t*, PIX*)
    • l_bootnum_gen1

      Pixa l_bootnum_gen1()
      Original signature : PIXA* l_bootnum_gen1()
    • l_bootnum_gen2

      Pixa l_bootnum_gen2()
      Original signature : PIXA* l_bootnum_gen2()
    • l_bootnum_gen3

      Pixa l_bootnum_gen3()
      Original signature : PIXA* l_bootnum_gen3()
    • boxCreate

      Box boxCreate(int x, int y, int w, int h)
      Original signature : BOX* boxCreate(l_int32, l_int32, l_int32, l_int32)
    • boxCreateValid

      Box boxCreateValid(int x, int y, int w, int h)
      Original signature : BOX* boxCreateValid(l_int32, l_int32, l_int32, l_int32)
    • boxCopy

      Box boxCopy(Box box)
      Original signature : BOX* boxCopy(BOX*)
    • boxClone

      Box boxClone(Box box)
      Original signature : BOX* boxClone(BOX*)
    • boxDestroy

      void boxDestroy(com.sun.jna.ptr.PointerByReference pbox)
      Original signature : void boxDestroy(BOX**)
    • boxGetGeometry

      int boxGetGeometry(Box box, IntBuffer px, IntBuffer py, IntBuffer pw, IntBuffer ph)
      Original signature : l_ok boxGetGeometry(BOX*, l_int32*, l_int32*, l_int32*, l_int32*)
    • boxSetGeometry

      int boxSetGeometry(Box box, int x, int y, int w, int h)
      Original signature : l_ok boxSetGeometry(BOX*, l_int32, l_int32, l_int32, l_int32)
    • boxGetSideLocations

      int boxGetSideLocations(Box box, IntBuffer pl, IntBuffer pr, IntBuffer pt, IntBuffer pb)
      Original signature : l_ok boxGetSideLocations(BOX*, l_int32*, l_int32*, l_int32*, l_int32*)
    • boxSetSideLocations

      int boxSetSideLocations(Box box, int l, int r, int t, int b)
      Original signature : l_ok boxSetSideLocations(BOX*, l_int32, l_int32, l_int32, l_int32)
    • boxGetRefcount

      int boxGetRefcount(Box box)
      Original signature : l_int32 boxGetRefcount(BOX*)
    • boxChangeRefcount

      int boxChangeRefcount(Box box, int delta)
      Original signature : l_ok boxChangeRefcount(BOX*, l_int32)
    • boxIsValid

      int boxIsValid(Box box, IntBuffer pvalid)
      Original signature : l_ok boxIsValid(BOX*, l_int32*)
    • boxaCreate

      Boxa boxaCreate(int n)
      Original signature : BOXA* boxaCreate(l_int32)
    • boxaCopy

      Boxa boxaCopy(Boxa boxa, int copyflag)
      Original signature : BOXA* boxaCopy(BOXA*, l_int32)
    • boxaDestroy

      void boxaDestroy(com.sun.jna.ptr.PointerByReference pboxa)
      Original signature : void boxaDestroy(BOXA**)
    • boxaAddBox

      int boxaAddBox(Boxa boxa, Box box, int copyflag)
      Original signature : l_ok boxaAddBox(BOXA*, BOX*, l_int32)
    • boxaExtendArray

      int boxaExtendArray(Boxa boxa)
      Original signature : l_ok boxaExtendArray(BOXA*)
    • boxaExtendArrayToSize

      int boxaExtendArrayToSize(Boxa boxa, NativeSize size)
      Original signature : l_ok boxaExtendArrayToSize(BOXA*, size_t)
    • boxaGetCount

      int boxaGetCount(Boxa boxa)
      Original signature : l_int32 boxaGetCount(BOXA*)
    • boxaGetValidCount

      int boxaGetValidCount(Boxa boxa)
      Original signature : l_int32 boxaGetValidCount(BOXA*)
    • boxaGetBox

      Box boxaGetBox(Boxa boxa, int index, int accessflag)
      Original signature : BOX* boxaGetBox(BOXA*, l_int32, l_int32)
    • boxaGetValidBox

      Box boxaGetValidBox(Boxa boxa, int index, int accessflag)
      Original signature : BOX* boxaGetValidBox(BOXA*, l_int32, l_int32)
    • boxaFindInvalidBoxes

      Numa boxaFindInvalidBoxes(Boxa boxa)
      Original signature : NUMA* boxaFindInvalidBoxes(BOXA*)
    • boxaGetBoxGeometry

      int boxaGetBoxGeometry(Boxa boxa, int index, IntBuffer px, IntBuffer py, IntBuffer pw, IntBuffer ph)
      Original signature : l_ok boxaGetBoxGeometry(BOXA*, l_int32, l_int32*, l_int32*, l_int32*, l_int32*)
    • boxaIsFull

      int boxaIsFull(Boxa boxa, IntBuffer pfull)
      Original signature : l_ok boxaIsFull(BOXA*, l_int32*)
    • boxaReplaceBox

      int boxaReplaceBox(Boxa boxa, int index, Box box)
      Original signature : l_ok boxaReplaceBox(BOXA*, l_int32, BOX*)
    • boxaInsertBox

      int boxaInsertBox(Boxa boxa, int index, Box box)
      Original signature : l_ok boxaInsertBox(BOXA*, l_int32, BOX*)
    • boxaRemoveBox

      int boxaRemoveBox(Boxa boxa, int index)
      Original signature : l_ok boxaRemoveBox(BOXA*, l_int32)
    • boxaRemoveBoxAndSave

      int boxaRemoveBoxAndSave(Boxa boxa, int index, com.sun.jna.ptr.PointerByReference pbox)
      Original signature : l_ok boxaRemoveBoxAndSave(BOXA*, l_int32, BOX**)
    • boxaSaveValid

      Boxa boxaSaveValid(Boxa boxas, int copyflag)
      Original signature : BOXA* boxaSaveValid(BOXA*, l_int32)
    • boxaInitFull

      int boxaInitFull(Boxa boxa, Box box)
      Original signature : l_ok boxaInitFull(BOXA*, BOX*)
    • boxaClear

      int boxaClear(Boxa boxa)
      Original signature : l_ok boxaClear(BOXA*)
    • boxaaReplaceBoxa

      int boxaaReplaceBoxa(Boxaa baa, int index, Boxa boxa)
      Original signature : l_ok boxaaReplaceBoxa(BOXAA*, l_int32, BOXA*)
    • boxaaInsertBoxa

      int boxaaInsertBoxa(Boxaa baa, int index, Boxa boxa)
      Original signature : l_ok boxaaInsertBoxa(BOXAA*, l_int32, BOXA*)
    • boxaaRemoveBoxa

      int boxaaRemoveBoxa(Boxaa baa, int index)
      Original signature : l_ok boxaaRemoveBoxa(BOXAA*, l_int32)
    • boxaaAddBox

      int boxaaAddBox(Boxaa baa, int index, Box box, int accessflag)
      Original signature : l_ok boxaaAddBox(BOXAA*, l_int32, BOX*, l_int32)
    • boxaaReadFromFiles

      Boxaa boxaaReadFromFiles(String dirname, String substr, int first, int nfiles)
      Original signature : BOXAA* boxaaReadFromFiles(const char*, const char*, l_int32, l_int32)
    • boxaaRead

      Boxaa boxaaRead(String filename)
      Original signature : BOXAA* boxaaRead(const char*)
    • boxaaReadMem

      Boxaa boxaaReadMem(ByteBuffer data, NativeSize size)
      Original signature : BOXAA* boxaaReadMem(const l_uint8*, size_t)
    • boxaaWrite

      int boxaaWrite(String filename, Boxaa baa)
      Original signature : l_ok boxaaWrite(const char*, BOXAA*)
    • boxaaWriteMem

      int boxaaWriteMem(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, Boxaa baa)
      Original signature : l_ok boxaaWriteMem(l_uint8**, size_t*, BOXAA*)
    • boxaRead

      Boxa boxaRead(String filename)
      Original signature : BOXA* boxaRead(const char*)
    • boxaReadMem

      Boxa boxaReadMem(ByteBuffer data, NativeSize size)
      Original signature : BOXA* boxaReadMem(const l_uint8*, size_t)
    • boxaWrite

      int boxaWrite(String filename, Boxa boxa)
      Original signature : l_ok boxaWrite(const char*, BOXA*)
    • boxaWriteMem

      int boxaWriteMem(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, Boxa boxa)
      Original signature : l_ok boxaWriteMem(l_uint8**, size_t*, BOXA*)
    • boxContains

      int boxContains(Box box1, Box box2, IntBuffer presult)
      Original signature : l_ok boxContains(BOX*, BOX*, l_int32*)
    • boxIntersects

      int boxIntersects(Box box1, Box box2, IntBuffer presult)
      Original signature : l_ok boxIntersects(BOX*, BOX*, l_int32*)
    • boxaContainedInBox

      Boxa boxaContainedInBox(Boxa boxas, Box box)
      Original signature : BOXA* boxaContainedInBox(BOXA*, BOX*)
    • boxaContainedInBoxCount

      int boxaContainedInBoxCount(Boxa boxa, Box box, IntBuffer pcount)
      Original signature : l_ok boxaContainedInBoxCount(BOXA*, BOX*, l_int32*)
    • boxaContainedInBoxa

      int boxaContainedInBoxa(Boxa boxa1, Boxa boxa2, IntBuffer pcontained)
      Original signature : l_ok boxaContainedInBoxa(BOXA*, BOXA*, l_int32*)
    • boxaIntersectsBox

      Boxa boxaIntersectsBox(Boxa boxas, Box box)
      Original signature : BOXA* boxaIntersectsBox(BOXA*, BOX*)
    • boxaIntersectsBoxCount

      int boxaIntersectsBoxCount(Boxa boxa, Box box, IntBuffer pcount)
      Original signature : l_ok boxaIntersectsBoxCount(BOXA*, BOX*, l_int32*)
    • boxaClipToBox

      Boxa boxaClipToBox(Boxa boxas, Box box)
      Original signature : BOXA* boxaClipToBox(BOXA*, BOX*)
    • boxaCombineOverlaps

      Boxa boxaCombineOverlaps(Boxa boxas, Pixa pixadb)
      Original signature : BOXA* boxaCombineOverlaps(BOXA*, PIXA*)
    • boxaCombineOverlapsInPair

      int boxaCombineOverlapsInPair(Boxa boxas1, Boxa boxas2, com.sun.jna.ptr.PointerByReference pboxad1, com.sun.jna.ptr.PointerByReference pboxad2, Pixa pixadb)
      Original signature : l_ok boxaCombineOverlapsInPair(BOXA*, BOXA*, BOXA**, BOXA**, PIXA*)
    • boxOverlapRegion

      Box boxOverlapRegion(Box box1, Box box2)
      Original signature : BOX* boxOverlapRegion(BOX*, BOX*)
    • boxBoundingRegion

      Box boxBoundingRegion(Box box1, Box box2)
      Original signature : BOX* boxBoundingRegion(BOX*, BOX*)
    • boxOverlapFraction

      int boxOverlapFraction(Box box1, Box box2, FloatBuffer pfract)
      Original signature : l_ok boxOverlapFraction(BOX*, BOX*, l_float32*)
    • boxOverlapArea

      int boxOverlapArea(Box box1, Box box2, IntBuffer parea)
      Original signature : l_ok boxOverlapArea(BOX*, BOX*, l_int32*)
    • boxaHandleOverlaps

      Boxa boxaHandleOverlaps(Boxa boxas, int op, int range, float min_overlap, float max_ratio, com.sun.jna.ptr.PointerByReference pnamap)
      Original signature : BOXA* boxaHandleOverlaps(BOXA*, l_int32, l_int32, l_float32, l_float32, NUMA**)
    • boxSeparationDistance

      int boxSeparationDistance(Box box1, Box box2, IntBuffer ph_sep, IntBuffer pv_sep)
      Original signature : l_ok boxSeparationDistance(BOX*, BOX*, l_int32*, l_int32*)
    • boxCompareSize

      int boxCompareSize(Box box1, Box box2, int type, IntBuffer prel)
      Original signature : l_ok boxCompareSize(BOX*, BOX*, l_int32, l_int32*)
    • boxContainsPt

      int boxContainsPt(Box box, float x, float y, IntBuffer pcontains)
      Original signature : l_ok boxContainsPt(BOX*, l_float32, l_float32, l_int32*)
    • boxaGetNearestToPt

      Box boxaGetNearestToPt(Boxa boxa, int x, int y)
      Original signature : BOX* boxaGetNearestToPt(BOXA*, l_int32, l_int32)
    • boxaGetNearestToLine

      Box boxaGetNearestToLine(Boxa boxa, int x, int y)
      Original signature : BOX* boxaGetNearestToLine(BOXA*, l_int32, l_int32)
    • boxGetCenter

      int boxGetCenter(Box box, FloatBuffer pcx, FloatBuffer pcy)
      Original signature : l_ok boxGetCenter(BOX*, l_float32*, l_float32*)
    • boxIntersectByLine

      int boxIntersectByLine(Box box, int x, int y, float slope, IntBuffer px1, IntBuffer py1, IntBuffer px2, IntBuffer py2, IntBuffer pn)
      Original signature : l_ok boxIntersectByLine(BOX*, l_int32, l_int32, l_float32, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*)
    • boxClipToRectangle

      Box boxClipToRectangle(Box box, int wi, int hi)
      Original signature : BOX* boxClipToRectangle(BOX*, l_int32, l_int32)
    • boxClipToRectangleParams

      int boxClipToRectangleParams(Box box, int w, int h, IntBuffer pxstart, IntBuffer pystart, IntBuffer pxend, IntBuffer pyend, IntBuffer pbw, IntBuffer pbh)
      Original signature : l_ok boxClipToRectangleParams(BOX*, l_int32, l_int32, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*)
    • boxRelocateOneSide

      Box boxRelocateOneSide(Box boxd, Box boxs, int loc, int sideflag)
      Original signature : BOX* boxRelocateOneSide(BOX*, BOX*, l_int32, l_int32)
    • boxaAdjustSides

      Boxa boxaAdjustSides(Boxa boxas, int delleft, int delright, int deltop, int delbot)
      Original signature : BOXA* boxaAdjustSides(BOXA*, l_int32, l_int32, l_int32, l_int32)
    • boxAdjustSides

      Box boxAdjustSides(Box boxd, Box boxs, int delleft, int delright, int deltop, int delbot)
      Original signature : BOX* boxAdjustSides(BOX*, BOX*, l_int32, l_int32, l_int32, l_int32)
    • boxaSetSide

      Boxa boxaSetSide(Boxa boxad, Boxa boxas, int side, int val, int thresh)
      Original signature : BOXA* boxaSetSide(BOXA*, BOXA*, l_int32, l_int32, l_int32)
    • boxaAdjustWidthToTarget

      Boxa boxaAdjustWidthToTarget(Boxa boxad, Boxa boxas, int sides, int target, int thresh)
      Original signature : BOXA* boxaAdjustWidthToTarget(BOXA*, BOXA*, l_int32, l_int32, l_int32)
    • boxaAdjustHeightToTarget

      Boxa boxaAdjustHeightToTarget(Boxa boxad, Boxa boxas, int sides, int target, int thresh)
      Original signature : BOXA* boxaAdjustHeightToTarget(BOXA*, BOXA*, l_int32, l_int32, l_int32)
    • boxEqual

      int boxEqual(Box box1, Box box2, IntBuffer psame)
      Original signature : l_ok boxEqual(BOX*, BOX*, l_int32*)
    • boxaEqual

      int boxaEqual(Boxa boxa1, Boxa boxa2, int maxdist, com.sun.jna.ptr.PointerByReference pnaindex, IntBuffer psame)
      Original signature : l_ok boxaEqual(BOXA*, BOXA*, l_int32, NUMA**, l_int32*)
    • boxaEqual

      int boxaEqual(Boxa boxa1, Boxa boxa2, int maxdist, com.sun.jna.ptr.PointerByReference pnaindex, com.sun.jna.ptr.IntByReference psame)
      Original signature : l_ok boxaEqual(BOXA*, BOXA*, l_int32, NUMA**, l_int32*)
    • boxSimilar

      int boxSimilar(Box box1, Box box2, int leftdiff, int rightdiff, int topdiff, int botdiff, IntBuffer psimilar)
      Original signature : l_ok boxSimilar(BOX*, BOX*, l_int32, l_int32, l_int32, l_int32, l_int32*)
    • boxaSimilar

      int boxaSimilar(Boxa boxa1, Boxa boxa2, int leftdiff, int rightdiff, int topdiff, int botdiff, int debug, IntBuffer psimilar, com.sun.jna.ptr.PointerByReference pnasim)
      Original signature : l_ok boxaSimilar(BOXA*, BOXA*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32*, NUMA**)
    • boxaSimilar

      int boxaSimilar(Boxa boxa1, Boxa boxa2, int leftdiff, int rightdiff, int topdiff, int botdiff, int debug, com.sun.jna.ptr.IntByReference psimilar, com.sun.jna.ptr.PointerByReference pnasim)
      Original signature : l_ok boxaSimilar(BOXA*, BOXA*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32*, NUMA**)
    • boxaJoin

      int boxaJoin(Boxa boxad, Boxa boxas, int istart, int iend)
      Original signature : l_ok boxaJoin(BOXA*, BOXA*, l_int32, l_int32)
    • boxaaJoin

      int boxaaJoin(Boxaa baad, Boxaa baas, int istart, int iend)
      Original signature : l_ok boxaaJoin(BOXAA*, BOXAA*, l_int32, l_int32)
    • pixMaskConnComp

      Pix pixMaskConnComp(Pix pixs, int connectivity, com.sun.jna.ptr.PointerByReference pboxa)
      Original signature : PIX* pixMaskConnComp(PIX*, l_int32, BOXA**)
    • pixMaskBoxa

      Pix pixMaskBoxa(Pix pixd, Pix pixs, Boxa boxa, int op)
      Original signature : PIX* pixMaskBoxa(PIX*, PIX*, BOXA*, l_int32)
    • pixPaintBoxa

      Pix pixPaintBoxa(Pix pixs, Boxa boxa, int val)
      Original signature : PIX* pixPaintBoxa(PIX*, BOXA*, l_uint32)
    • pixSetBlackOrWhiteBoxa

      Pix pixSetBlackOrWhiteBoxa(Pix pixs, Boxa boxa, int op)
      Original signature : PIX* pixSetBlackOrWhiteBoxa(PIX*, BOXA*, l_int32)
    • pixPaintBoxaRandom

      Pix pixPaintBoxaRandom(Pix pixs, Boxa boxa)
      Original signature : PIX* pixPaintBoxaRandom(PIX*, BOXA*)
    • pixBlendBoxaRandom

      Pix pixBlendBoxaRandom(Pix pixs, Boxa boxa, float fract)
      Original signature : PIX* pixBlendBoxaRandom(PIX*, BOXA*, l_float32)
    • pixDrawBoxa

      Pix pixDrawBoxa(Pix pixs, Boxa boxa, int width, int val)
      Original signature : PIX* pixDrawBoxa(PIX*, BOXA*, l_int32, l_uint32)
    • pixDrawBoxaRandom

      Pix pixDrawBoxaRandom(Pix pixs, Boxa boxa, int width)
      Original signature : PIX* pixDrawBoxaRandom(PIX*, BOXA*, l_int32)
    • boxaaDisplay

      Pix boxaaDisplay(Pix pixs, Boxaa baa, int linewba, int linewb, int colorba, int colorb, int w, int h)
      Original signature : PIX* boxaaDisplay(PIX*, BOXAA*, l_int32, l_int32, l_uint32, l_uint32, l_int32, l_int32)
    • pixaDisplayBoxaa

      Pixa pixaDisplayBoxaa(Pixa pixas, Boxaa baa, int colorflag, int width)
      Original signature : PIXA* pixaDisplayBoxaa(PIXA*, BOXAA*, l_int32, l_int32)
    • pixSplitIntoBoxa

      Boxa pixSplitIntoBoxa(Pix pixs, int minsum, int skipdist, int delta, int maxbg, int maxcomps, int remainder)
      Original signature : BOXA* pixSplitIntoBoxa(PIX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixSplitComponentIntoBoxa

      Boxa pixSplitComponentIntoBoxa(Pix pix, Box box, int minsum, int skipdist, int delta, int maxbg, int maxcomps, int remainder)
      Original signature : BOXA* pixSplitComponentIntoBoxa(PIX*, BOX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32)
    • boxaCompareRegions

      int boxaCompareRegions(Boxa boxa1, Boxa boxa2, int areathresh, IntBuffer pnsame, FloatBuffer pdiffarea, FloatBuffer pdiffxor, com.sun.jna.ptr.PointerByReference ppixdb)
      Original signature : l_ok boxaCompareRegions(BOXA*, BOXA*, l_int32, l_int32*, l_float32*, l_float32*, PIX**)
    • boxaCompareRegions

      int boxaCompareRegions(Boxa boxa1, Boxa boxa2, int areathresh, com.sun.jna.ptr.IntByReference pnsame, com.sun.jna.ptr.FloatByReference pdiffarea, com.sun.jna.ptr.FloatByReference pdiffxor, com.sun.jna.ptr.PointerByReference ppixdb)
      Original signature : l_ok boxaCompareRegions(BOXA*, BOXA*, l_int32, l_int32*, l_float32*, l_float32*, PIX**)
    • boxaSelectRange

      Boxa boxaSelectRange(Boxa boxas, int first, int last, int copyflag)
      Original signature : BOXA* boxaSelectRange(BOXA*, l_int32, l_int32, l_int32)
    • boxaaSelectRange

      Boxaa boxaaSelectRange(Boxaa baas, int first, int last, int copyflag)
      Original signature : BOXAA* boxaaSelectRange(BOXAA*, l_int32, l_int32, l_int32)
    • boxaSelectBySize

      Boxa boxaSelectBySize(Boxa boxas, int width, int height, int type, int relation, IntBuffer pchanged)
      Original signature : BOXA* boxaSelectBySize(BOXA*, l_int32, l_int32, l_int32, l_int32, l_int32*)
    • boxaMakeSizeIndicator

      Numa boxaMakeSizeIndicator(Boxa boxa, int width, int height, int type, int relation)
      Original signature : NUMA* boxaMakeSizeIndicator(BOXA*, l_int32, l_int32, l_int32, l_int32)
    • boxaSelectByArea

      Boxa boxaSelectByArea(Boxa boxas, int area, int relation, IntBuffer pchanged)
      Original signature : BOXA* boxaSelectByArea(BOXA*, l_int32, l_int32, l_int32*)
    • boxaSwapBoxes

      int boxaSwapBoxes(Boxa boxa, int i, int j)
      Original signature : l_ok boxaSwapBoxes(BOXA*, l_int32, l_int32)
    • boxaConvertToPta

      Pta boxaConvertToPta(Boxa boxa, int ncorners)
      Original signature : PTA* boxaConvertToPta(BOXA*, l_int32)
    • ptaConvertToBoxa

      Boxa ptaConvertToBoxa(Pta pta, int ncorners)
      Original signature : BOXA* ptaConvertToBoxa(PTA*, l_int32)
    • boxConvertToPta

      Pta boxConvertToPta(Box box, int ncorners)
      Original signature : PTA* boxConvertToPta(BOX*, l_int32)
    • ptaConvertToBox

      Box ptaConvertToBox(Pta pta)
      Original signature : BOX* ptaConvertToBox(PTA*)
    • boxaGetCoverage

      int boxaGetCoverage(Boxa boxa, int wc, int hc, int exactflag, FloatBuffer pfract)
      Original signature : l_ok boxaGetCoverage(BOXA*, l_int32, l_int32, l_int32, l_float32*)
    • boxaaSizeRange

      int boxaaSizeRange(Boxaa baa, IntBuffer pminw, IntBuffer pminh, IntBuffer pmaxw, IntBuffer pmaxh)
      Original signature : l_ok boxaaSizeRange(BOXAA*, l_int32*, l_int32*, l_int32*, l_int32*)
    • boxaSizeRange

      int boxaSizeRange(Boxa boxa, IntBuffer pminw, IntBuffer pminh, IntBuffer pmaxw, IntBuffer pmaxh)
      Original signature : l_ok boxaSizeRange(BOXA*, l_int32*, l_int32*, l_int32*, l_int32*)
    • boxaLocationRange

      int boxaLocationRange(Boxa boxa, IntBuffer pminx, IntBuffer pminy, IntBuffer pmaxx, IntBuffer pmaxy)
      Original signature : l_ok boxaLocationRange(BOXA*, l_int32*, l_int32*, l_int32*, l_int32*)
    • boxaGetSizes

      int boxaGetSizes(Boxa boxa, com.sun.jna.ptr.PointerByReference pnaw, com.sun.jna.ptr.PointerByReference pnah)
      Original signature : l_ok boxaGetSizes(BOXA*, NUMA**, NUMA**)
    • boxaGetArea

      int boxaGetArea(Boxa boxa, IntBuffer parea)
      Original signature : l_ok boxaGetArea(BOXA*, l_int32*)
    • boxaDisplayTiled

      Pix boxaDisplayTiled(Boxa boxas, Pixa pixa, int maxwidth, int linewidth, float scalefactor, int background, int spacing, int border)
      Original signature : PIX* boxaDisplayTiled(BOXA*, PIXA*, l_int32, l_int32, l_float32, l_int32, l_int32, l_int32)
    • ccbaCreate

      CCBorda ccbaCreate(Pix pixs, int n)
      Original signature : CCBORDA* ccbaCreate(PIX*, l_int32)
    • ccbaDestroy

      void ccbaDestroy(com.sun.jna.ptr.PointerByReference pccba)
      Original signature : void ccbaDestroy(CCBORDA**)
    • ccbCreate

      CCBord ccbCreate(Pix pixs)
      Original signature : CCBORD* ccbCreate(PIX*)
    • ccbDestroy

      void ccbDestroy(com.sun.jna.ptr.PointerByReference pccb)
      Original signature : void ccbDestroy(CCBORD**)
    • ccbaAddCcb

      int ccbaAddCcb(CCBorda ccba, CCBord ccb)
      Original signature : l_ok ccbaAddCcb(CCBORDA*, CCBORD*)
    • ccbaGetCount

      int ccbaGetCount(CCBorda ccba)
      Original signature : l_int32 ccbaGetCount(CCBORDA*)
    • ccbaGetCcb

      CCBord ccbaGetCcb(CCBorda ccba, int index)
      Original signature : CCBORD* ccbaGetCcb(CCBORDA*, l_int32)
    • pixGetAllCCBorders

      CCBorda pixGetAllCCBorders(Pix pixs)
      Original signature : CCBORDA* pixGetAllCCBorders(PIX*)
    • pixGetOuterBorderPta

      Pta pixGetOuterBorderPta(Pix pixs, Box box)
      Original signature : PTA* pixGetOuterBorderPta(PIX*, BOX*)
    • pixGetOuterBorder

      int pixGetOuterBorder(CCBord ccb, Pix pixs, Box box)
      Original signature : l_ok pixGetOuterBorder(CCBORD*, PIX*, BOX*)
    • ccbaGenerateGlobalLocs

      int ccbaGenerateGlobalLocs(CCBorda ccba)
      Original signature : l_ok ccbaGenerateGlobalLocs(CCBORDA*)
    • ccbaGenerateStepChains

      int ccbaGenerateStepChains(CCBorda ccba)
      Original signature : l_ok ccbaGenerateStepChains(CCBORDA*)
    • ccbaStepChainsToPixCoords

      int ccbaStepChainsToPixCoords(CCBorda ccba, int coordtype)
      Original signature : l_ok ccbaStepChainsToPixCoords(CCBORDA*, l_int32)
    • ccbaGenerateSPGlobalLocs

      int ccbaGenerateSPGlobalLocs(CCBorda ccba, int ptsflag)
      Original signature : l_ok ccbaGenerateSPGlobalLocs(CCBORDA*, l_int32)
    • ccbaGenerateSinglePath

      int ccbaGenerateSinglePath(CCBorda ccba)
      Original signature : l_ok ccbaGenerateSinglePath(CCBORDA*)
    • getCutPathForHole

      Pta getCutPathForHole(Pix pix, Pta pta, Box boxinner, IntBuffer pdir, IntBuffer plen)
      Original signature : PTA* getCutPathForHole(PIX*, PTA*, BOX*, l_int32*, l_int32*)
    • ccbaDisplayBorder

      Pix ccbaDisplayBorder(CCBorda ccba)
      Original signature : PIX* ccbaDisplayBorder(CCBORDA*)
    • ccbaDisplaySPBorder

      Pix ccbaDisplaySPBorder(CCBorda ccba)
      Original signature : PIX* ccbaDisplaySPBorder(CCBORDA*)
    • ccbaDisplayImage1

      Pix ccbaDisplayImage1(CCBorda ccba)
      Original signature : PIX* ccbaDisplayImage1(CCBORDA*)
    • ccbaDisplayImage2

      Pix ccbaDisplayImage2(CCBorda ccba)
      Original signature : PIX* ccbaDisplayImage2(CCBORDA*)
    • ccbaWrite

      int ccbaWrite(String filename, CCBorda ccba)
      Original signature : l_ok ccbaWrite(const char*, CCBORDA*)
    • ccbaRead

      CCBorda ccbaRead(String filename)
      Original signature : CCBORDA* ccbaRead(const char*)
    • pixaThinConnected

      Pixa pixaThinConnected(Pixa pixas, int type, int connectivity, int maxiters)
      Original signature : PIXA* pixaThinConnected(PIXA*, l_int32, l_int32, l_int32)
    • pixThinConnected

      Pix pixThinConnected(Pix pixs, int type, int connectivity, int maxiters)
      Original signature : PIX* pixThinConnected(PIX*, l_int32, l_int32, l_int32)
    • pixThinConnectedBySet

      Pix pixThinConnectedBySet(Pix pixs, int type, Sela sela, int maxiters)
      Original signature : PIX* pixThinConnectedBySet(PIX*, l_int32, SELA*, l_int32)
    • selaMakeThinSets

      Sela selaMakeThinSets(int index, int debug)
      Original signature : SELA* selaMakeThinSets(l_int32, l_int32)
    • jbCorrelation

      int jbCorrelation(String dirin, float thresh, float weight, int components, String rootname, int firstpage, int npages, int renderflag)
      Original signature : l_ok jbCorrelation(const char*, l_float32, l_float32, l_int32, const char*, l_int32, l_int32, l_int32)
    • jbRankHaus

      int jbRankHaus(String dirin, int size, float rank, int components, String rootname, int firstpage, int npages, int renderflag)
      Original signature : l_ok jbRankHaus(const char*, l_int32, l_float32, l_int32, const char*, l_int32, l_int32, l_int32)
    • jbWordsInTextlines

      JbClasser jbWordsInTextlines(String dirin, int reduction, int maxwidth, int maxheight, float thresh, float weight, com.sun.jna.ptr.PointerByReference pnatl, int firstpage, int npages)
      Original signature : JBCLASSER* jbWordsInTextlines(const char*, l_int32, l_int32, l_int32, l_float32, l_float32, NUMA**, l_int32, l_int32)
    • jbWordsInTextlines

      JbClasser jbWordsInTextlines(com.sun.jna.Pointer dirin, int reduction, int maxwidth, int maxheight, float thresh, float weight, com.sun.jna.ptr.PointerByReference pnatl, int firstpage, int npages)
      Original signature : JBCLASSER* jbWordsInTextlines(const char*, l_int32, l_int32, l_int32, l_float32, l_float32, NUMA**, l_int32, l_int32)
    • pixGetWordsInTextlines

      int pixGetWordsInTextlines(Pix pixs, int minwidth, int minheight, int maxwidth, int maxheight, com.sun.jna.ptr.PointerByReference pboxad, com.sun.jna.ptr.PointerByReference ppixad, com.sun.jna.ptr.PointerByReference pnai)
      Original signature : l_ok pixGetWordsInTextlines(PIX*, l_int32, l_int32, l_int32, l_int32, BOXA**, PIXA**, NUMA**)
    • pixGetWordBoxesInTextlines

      int pixGetWordBoxesInTextlines(Pix pixs, int minwidth, int minheight, int maxwidth, int maxheight, com.sun.jna.ptr.PointerByReference pboxad, com.sun.jna.ptr.PointerByReference pnai)
      Original signature : l_ok pixGetWordBoxesInTextlines(PIX*, l_int32, l_int32, l_int32, l_int32, BOXA**, NUMA**)
    • boxaExtractSortedPattern

      Numaa boxaExtractSortedPattern(Boxa boxa, Numa na)
      Original signature : NUMAA* boxaExtractSortedPattern(BOXA*, NUMA*)
    • numaaCompareImagesByBoxes

      int numaaCompareImagesByBoxes(Numaa naa1, Numaa naa2, int nperline, int nreq, int maxshiftx, int maxshifty, int delx, int dely, IntBuffer psame, int debugflag)
      Original signature : l_ok numaaCompareImagesByBoxes(NUMAA*, NUMAA*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32*, l_int32)
    • pixColorContent

      int pixColorContent(Pix pixs, int rref, int gref, int bref, int mingray, com.sun.jna.ptr.PointerByReference ppixr, com.sun.jna.ptr.PointerByReference ppixg, com.sun.jna.ptr.PointerByReference ppixb)
      Original signature : l_ok pixColorContent(PIX*, l_int32, l_int32, l_int32, l_int32, PIX**, PIX**, PIX**)
    • pixColorMagnitude

      Pix pixColorMagnitude(Pix pixs, int rref, int gref, int bref, int type)
      Original signature : PIX* pixColorMagnitude(PIX*, l_int32, l_int32, l_int32, l_int32)
    • pixColorFraction

      int pixColorFraction(Pix pixs, int darkthresh, int lightthresh, int diffthresh, int factor, FloatBuffer ppixfract, FloatBuffer pcolorfract)
      Original signature : l_ok pixColorFraction(PIX*, l_int32, l_int32, l_int32, l_int32, l_float32*, l_float32*)
    • pixColorShiftWhitePoint

      Pix pixColorShiftWhitePoint(Pix pixs, int rref, int gref, int bref)
      Original signature : PIX* pixColorShiftWhitePoint(PIX*, l_int32, l_int32, l_int32)
    • pixMaskOverColorPixels

      Pix pixMaskOverColorPixels(Pix pixs, int threshdiff, int mindist)
      Original signature : PIX* pixMaskOverColorPixels(PIX*, l_int32, l_int32)
    • pixFindColorRegions

      int pixFindColorRegions(Pix pixs, Pix pixm, int factor, int lightthresh, int darkthresh, int mindiff, int colordiff, float edgefract, FloatBuffer pcolorfract, com.sun.jna.ptr.PointerByReference pcolormask1, com.sun.jna.ptr.PointerByReference pcolormask2, Pixa pixadb)
      Original signature : l_ok pixFindColorRegions(PIX*, PIX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_float32, l_float32*, PIX**, PIX**, PIXA*)
    • pixFindColorRegions

      int pixFindColorRegions(Pix pixs, Pix pixm, int factor, int lightthresh, int darkthresh, int mindiff, int colordiff, float edgefract, com.sun.jna.ptr.FloatByReference pcolorfract, com.sun.jna.ptr.PointerByReference pcolormask1, com.sun.jna.ptr.PointerByReference pcolormask2, Pixa pixadb)
      Original signature : l_ok pixFindColorRegions(PIX*, PIX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_float32, l_float32*, PIX**, PIX**, PIXA*)
    • pixNumSignificantGrayColors

      int pixNumSignificantGrayColors(Pix pixs, int darkthresh, int lightthresh, float minfract, int factor, IntBuffer pncolors)
      Original signature : l_ok pixNumSignificantGrayColors(PIX*, l_int32, l_int32, l_float32, l_int32, l_int32*)
    • pixColorsForQuantization

      int pixColorsForQuantization(Pix pixs, int thresh, IntBuffer pncolors, IntBuffer piscolor, int debug)
      Original signature : l_ok pixColorsForQuantization(PIX*, l_int32, l_int32*, l_int32*, l_int32)
    • pixNumColors

      int pixNumColors(Pix pixs, int factor, IntBuffer pncolors)
      Original signature : l_ok pixNumColors(PIX*, l_int32, l_int32*)
    • pixConvertRGBToCmapLossless

      Pix pixConvertRGBToCmapLossless(Pix pixs)
      Original signature : PIX* pixConvertRGBToCmapLossless(PIX*)
    • pixGetMostPopulatedColors

      int pixGetMostPopulatedColors(Pix pixs, int sigbits, int factor, int ncolors, com.sun.jna.ptr.PointerByReference parray, com.sun.jna.ptr.PointerByReference pcmap)
      Original signature : l_ok pixGetMostPopulatedColors(PIX*, l_int32, l_int32, l_int32, l_uint32**, PIXCMAP**)
    • pixSimpleColorQuantize

      Pix pixSimpleColorQuantize(Pix pixs, int sigbits, int factor, int ncolors)
      Original signature : PIX* pixSimpleColorQuantize(PIX*, l_int32, l_int32, l_int32)
    • pixGetRGBHistogram

      Numa pixGetRGBHistogram(Pix pixs, int sigbits, int factor)
      Original signature : NUMA* pixGetRGBHistogram(PIX*, l_int32, l_int32)
    • makeRGBIndexTables

      int makeRGBIndexTables(com.sun.jna.ptr.PointerByReference prtab, com.sun.jna.ptr.PointerByReference pgtab, com.sun.jna.ptr.PointerByReference pbtab, int sigbits)
      Original signature : l_ok makeRGBIndexTables(l_uint32**, l_uint32**, l_uint32**, l_int32)
    • getRGBFromIndex

      int getRGBFromIndex(int index, int sigbits, IntBuffer prval, IntBuffer pgval, IntBuffer pbval)
      Original signature : l_ok getRGBFromIndex(l_uint32, l_int32, l_int32*, l_int32*, l_int32*)
    • pixHasHighlightRed

      int pixHasHighlightRed(Pix pixs, int factor, float minfract, float fthresh, IntBuffer phasred, FloatBuffer pratio, com.sun.jna.ptr.PointerByReference ppixdb)
      Original signature : l_ok pixHasHighlightRed(PIX*, l_int32, l_float32, l_float32, l_int32*, l_float32*, PIX**)
    • pixHasHighlightRed

      int pixHasHighlightRed(Pix pixs, int factor, float minfract, float fthresh, com.sun.jna.ptr.IntByReference phasred, com.sun.jna.ptr.FloatByReference pratio, com.sun.jna.ptr.PointerByReference ppixdb)
      Original signature : l_ok pixHasHighlightRed(PIX*, l_int32, l_float32, l_float32, l_int32*, l_float32*, PIX**)
    • pixColorGrayRegions

      Pix pixColorGrayRegions(Pix pixs, Boxa boxa, int type, int thresh, int rval, int gval, int bval)
      Original signature : PIX* pixColorGrayRegions(PIX*, BOXA*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixColorGray

      int pixColorGray(Pix pixs, Box box, int type, int thresh, int rval, int gval, int bval)
      Original signature : l_ok pixColorGray(PIX*, BOX*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixColorGrayMasked

      Pix pixColorGrayMasked(Pix pixs, Pix pixm, int type, int thresh, int rval, int gval, int bval)
      Original signature : PIX* pixColorGrayMasked(PIX*, PIX*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixSnapColor

      Pix pixSnapColor(Pix pixd, Pix pixs, int srcval, int dstval, int diff)
      Original signature : PIX* pixSnapColor(PIX*, PIX*, l_uint32, l_uint32, l_int32)
    • pixSnapColorCmap

      Pix pixSnapColorCmap(Pix pixd, Pix pixs, int srcval, int dstval, int diff)
      Original signature : PIX* pixSnapColorCmap(PIX*, PIX*, l_uint32, l_uint32, l_int32)
    • pixLinearMapToTargetColor

      Pix pixLinearMapToTargetColor(Pix pixd, Pix pixs, int srcval, int dstval)
      Original signature : PIX* pixLinearMapToTargetColor(PIX*, PIX*, l_uint32, l_uint32)
    • pixelLinearMapToTargetColor

      int pixelLinearMapToTargetColor(int scolor, int srcmap, int dstmap, IntBuffer pdcolor)
      Original signature : l_ok pixelLinearMapToTargetColor(l_uint32, l_uint32, l_uint32, l_uint32*)
    • pixShiftByComponent

      Pix pixShiftByComponent(Pix pixd, Pix pixs, int srcval, int dstval)
      Original signature : PIX* pixShiftByComponent(PIX*, PIX*, l_uint32, l_uint32)
    • pixcmapGetDistanceToColor

      int pixcmapGetDistanceToColor(PixColormap cmap, int index, int rval, int gval, int bval, IntBuffer pdist)
      Original signature : l_ok pixcmapGetDistanceToColor(PIXCMAP*, l_int32, l_int32, l_int32, l_int32, l_int32*)
    • pixcmapGetRangeValues

      int pixcmapGetRangeValues(PixColormap cmap, int select, IntBuffer pminval, IntBuffer pmaxval, IntBuffer pminindex, IntBuffer pmaxindex)
      Original signature : l_ok pixcmapGetRangeValues(PIXCMAP*, l_int32, l_int32*, l_int32*, l_int32*, l_int32*)
    • pixcmapConvertTo4

      PixColormap pixcmapConvertTo4(PixColormap cmaps)
      Original signature : PIXCMAP* pixcmapConvertTo4(PIXCMAP*)
    • pixcmapConvertTo8

      PixColormap pixcmapConvertTo8(PixColormap cmaps)
      Original signature : PIXCMAP* pixcmapConvertTo8(PIXCMAP*)
    • pixcmapReadMem

      PixColormap pixcmapReadMem(ByteBuffer data, NativeSize size)
      Original signature : PIXCMAP* pixcmapReadMem(const l_uint8*, size_t)
    • pixcmapWrite

      int pixcmapWrite(String filename, PixColormap cmap)
      Original signature : l_ok pixcmapWrite(const char*, PIXCMAP*)
    • pixcmapWriteMem

      int pixcmapWriteMem(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, PixColormap cmap)
      Original signature : l_ok pixcmapWriteMem(l_uint8**, size_t*, PIXCMAP*)
    • pixColorMorph

      Pix pixColorMorph(Pix pixs, int type, int hsize, int vsize)
      Original signature : PIX* pixColorMorph(PIX*, l_int32, l_int32, l_int32)
    • pixOctreeColorQuant

      Pix pixOctreeColorQuant(Pix pixs, int colors, int ditherflag)
      Original signature : PIX* pixOctreeColorQuant(PIX*, l_int32, l_int32)
    • pixOctreeColorQuantGeneral

      Pix pixOctreeColorQuantGeneral(Pix pixs, int colors, int ditherflag, float validthresh, float colorthresh)
      Original signature : PIX* pixOctreeColorQuantGeneral(PIX*, l_int32, l_int32, l_float32, l_float32)
    • makeRGBToIndexTables

      int makeRGBToIndexTables(int cqlevels, com.sun.jna.ptr.PointerByReference prtab, com.sun.jna.ptr.PointerByReference pgtab, com.sun.jna.ptr.PointerByReference pbtab)
      Original signature : l_ok makeRGBToIndexTables(l_uint32, l_uint32**, l_uint32**, l_int32**)
    • getOctcubeIndexFromRGB

      void getOctcubeIndexFromRGB(int rval, int gval, int bval, IntBuffer rtab, IntBuffer gtab, IntBuffer btab, IntBuffer pindex)
      Original signature : void getOctcubeIndexFromRGB(l_int32, l_int32, l_int32, l_uint32*, l_uint32*, l_uint32*, l_uint32*)
    • pixOctreeQuantByPopulation

      Pix pixOctreeQuantByPopulation(Pix pixs, int level, int ditherflag)
      Original signature : PIX* pixOctreeQuantByPopulation(PIX*, l_int32, l_int32)
    • pixOctreeQuantNumColors

      Pix pixOctreeQuantNumColors(Pix pixs, int maxcolors, int subsample)
      Original signature : PIX* pixOctreeQuantNumColors(PIX*, l_int32, l_int32)
    • pixOctcubeQuantMixedWithGray

      Pix pixOctcubeQuantMixedWithGray(Pix pixs, int depth, int graylevels, int delta)
      Original signature : PIX* pixOctcubeQuantMixedWithGray(PIX*, l_int32, l_int32, l_int32)
    • pixFixedOctcubeQuant256

      Pix pixFixedOctcubeQuant256(Pix pixs, int ditherflag)
      Original signature : PIX* pixFixedOctcubeQuant256(PIX*, l_int32)
    • pixFewColorsOctcubeQuant1

      Pix pixFewColorsOctcubeQuant1(Pix pixs, int level)
      Original signature : PIX* pixFewColorsOctcubeQuant1(PIX*, l_int32)
    • pixFewColorsOctcubeQuant2

      Pix pixFewColorsOctcubeQuant2(Pix pixs, int level, Numa na, int ncolors, IntBuffer pnerrors)
      Original signature : PIX* pixFewColorsOctcubeQuant2(PIX*, l_int32, NUMA*, l_int32, l_int32*)
    • pixFewColorsOctcubeQuantMixed

      Pix pixFewColorsOctcubeQuantMixed(Pix pixs, int level, int darkthresh, int lightthresh, int diffthresh, float minfract, int maxspan)
      Original signature : PIX* pixFewColorsOctcubeQuantMixed(PIX*, l_int32, l_int32, l_int32, l_int32, l_float32, l_int32)
    • pixFixedOctcubeQuantGenRGB

      Pix pixFixedOctcubeQuantGenRGB(Pix pixs, int level)
      Original signature : PIX* pixFixedOctcubeQuantGenRGB(PIX*, l_int32)
    • pixQuantFromCmap

      Pix pixQuantFromCmap(Pix pixs, PixColormap cmap, int mindepth, int level, int metric)
      Original signature : PIX* pixQuantFromCmap(PIX*, PIXCMAP*, l_int32, l_int32, l_int32)
    • pixOctcubeQuantFromCmap

      Pix pixOctcubeQuantFromCmap(Pix pixs, PixColormap cmap, int mindepth, int level, int metric)
      Original signature : PIX* pixOctcubeQuantFromCmap(PIX*, PIXCMAP*, l_int32, l_int32, l_int32)
    • pixOctcubeHistogram

      Numa pixOctcubeHistogram(Pix pixs, int level, IntBuffer pncolors)
      Original signature : NUMA* pixOctcubeHistogram(PIX*, l_int32, l_int32*)
    • pixcmapToOctcubeLUT

      com.sun.jna.ptr.IntByReference pixcmapToOctcubeLUT(PixColormap cmap, int level, int metric)
      Original signature : l_int32* pixcmapToOctcubeLUT(PIXCMAP*, l_int32, l_int32)
    • pixRemoveUnusedColors

      int pixRemoveUnusedColors(Pix pixs)
      Original signature : l_ok pixRemoveUnusedColors(PIX*)
    • pixNumberOccupiedOctcubes

      int pixNumberOccupiedOctcubes(Pix pix, int level, int mincount, float minfract, IntBuffer pncolors)
      Original signature : l_ok pixNumberOccupiedOctcubes(PIX*, l_int32, l_int32, l_float32, l_int32*)
    • pixMedianCutQuant

      Pix pixMedianCutQuant(Pix pixs, int ditherflag)
      Original signature : PIX* pixMedianCutQuant(PIX*, l_int32)
    • pixMedianCutQuantGeneral

      Pix pixMedianCutQuantGeneral(Pix pixs, int ditherflag, int outdepth, int maxcolors, int sigbits, int maxsub, int checkbw)
      Original signature : PIX* pixMedianCutQuantGeneral(PIX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixMedianCutQuantMixed

      Pix pixMedianCutQuantMixed(Pix pixs, int ncolor, int ngray, int darkthresh, int lightthresh, int diffthresh)
      Original signature : PIX* pixMedianCutQuantMixed(PIX*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixFewColorsMedianCutQuantMixed

      Pix pixFewColorsMedianCutQuantMixed(Pix pixs, int ncolor, int ngray, int maxncolors, int darkthresh, int lightthresh, int diffthresh)
      Original signature : PIX* pixFewColorsMedianCutQuantMixed(PIX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixMedianCutHisto

      com.sun.jna.ptr.IntByReference pixMedianCutHisto(Pix pixs, int sigbits, int subsample)
      Original signature : l_int32* pixMedianCutHisto(PIX*, l_int32, l_int32)
    • pixColorSegment

      Pix pixColorSegment(Pix pixs, int maxdist, int maxcolors, int selsize, int finalcolors, int debugflag)
      Original signature : PIX* pixColorSegment(PIX*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixColorSegmentCluster

      Pix pixColorSegmentCluster(Pix pixs, int maxdist, int maxcolors, int debugflag)
      Original signature : PIX* pixColorSegmentCluster(PIX*, l_int32, l_int32, l_int32)
    • pixAssignToNearestColor

      int pixAssignToNearestColor(Pix pixd, Pix pixs, Pix pixm, int level, IntBuffer countarray)
      Original signature : l_ok pixAssignToNearestColor(PIX*, PIX*, PIX*, l_int32, l_int32*)
    • pixColorSegmentClean

      int pixColorSegmentClean(Pix pixs, int selsize, IntBuffer countarray)
      Original signature : l_ok pixColorSegmentClean(PIX*, l_int32, l_int32*)
    • pixColorSegmentRemoveColors

      int pixColorSegmentRemoveColors(Pix pixd, Pix pixs, int finalcolors)
      Original signature : l_ok pixColorSegmentRemoveColors(PIX*, PIX*, l_int32)
    • pixConvertRGBToHSV

      Pix pixConvertRGBToHSV(Pix pixd, Pix pixs)
      Original signature : PIX* pixConvertRGBToHSV(PIX*, PIX*)
    • pixConvertHSVToRGB

      Pix pixConvertHSVToRGB(Pix pixd, Pix pixs)
      Original signature : PIX* pixConvertHSVToRGB(PIX*, PIX*)
    • convertRGBToHSV

      int convertRGBToHSV(int rval, int gval, int bval, IntBuffer phval, IntBuffer psval, IntBuffer pvval)
      Original signature : l_ok convertRGBToHSV(l_int32, l_int32, l_int32, l_int32*, l_int32*, l_int32*)
    • convertHSVToRGB

      int convertHSVToRGB(int hval, int sval, int vval, IntBuffer prval, IntBuffer pgval, IntBuffer pbval)
      Original signature : l_ok convertHSVToRGB(l_int32, l_int32, l_int32, l_int32*, l_int32*, l_int32*)
    • pixcmapConvertRGBToHSV

      int pixcmapConvertRGBToHSV(PixColormap cmap)
      Original signature : l_ok pixcmapConvertRGBToHSV(PIXCMAP*)
    • pixcmapConvertHSVToRGB

      int pixcmapConvertHSVToRGB(PixColormap cmap)
      Original signature : l_ok pixcmapConvertHSVToRGB(PIXCMAP*)
    • pixConvertRGBToHue

      Pix pixConvertRGBToHue(Pix pixs)
      Original signature : PIX* pixConvertRGBToHue(PIX*)
    • pixConvertRGBToSaturation

      Pix pixConvertRGBToSaturation(Pix pixs)
      Original signature : PIX* pixConvertRGBToSaturation(PIX*)
    • pixConvertRGBToValue

      Pix pixConvertRGBToValue(Pix pixs)
      Original signature : PIX* pixConvertRGBToValue(PIX*)
    • pixMakeRangeMaskHS

      Pix pixMakeRangeMaskHS(Pix pixs, int huecenter, int huehw, int satcenter, int sathw, int regionflag)
      Original signature : PIX* pixMakeRangeMaskHS(PIX*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixMakeRangeMaskHV

      Pix pixMakeRangeMaskHV(Pix pixs, int huecenter, int huehw, int valcenter, int valhw, int regionflag)
      Original signature : PIX* pixMakeRangeMaskHV(PIX*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixMakeRangeMaskSV

      Pix pixMakeRangeMaskSV(Pix pixs, int satcenter, int sathw, int valcenter, int valhw, int regionflag)
      Original signature : PIX* pixMakeRangeMaskSV(PIX*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixMakeHistoHS

      Pix pixMakeHistoHS(Pix pixs, int factor, com.sun.jna.ptr.PointerByReference pnahue, com.sun.jna.ptr.PointerByReference pnasat)
      Original signature : PIX* pixMakeHistoHS(PIX*, l_int32, NUMA**, NUMA**)
    • pixMakeHistoHV

      Pix pixMakeHistoHV(Pix pixs, int factor, com.sun.jna.ptr.PointerByReference pnahue, com.sun.jna.ptr.PointerByReference pnaval)
      Original signature : PIX* pixMakeHistoHV(PIX*, l_int32, NUMA**, NUMA**)
    • pixMakeHistoSV

      Pix pixMakeHistoSV(Pix pixs, int factor, com.sun.jna.ptr.PointerByReference pnasat, com.sun.jna.ptr.PointerByReference pnaval)
      Original signature : PIX* pixMakeHistoSV(PIX*, l_int32, NUMA**, NUMA**)
    • pixFindHistoPeaksHSV

      int pixFindHistoPeaksHSV(Pix pixs, int type, int width, int height, int npeaks, float erasefactor, com.sun.jna.ptr.PointerByReference ppta, com.sun.jna.ptr.PointerByReference pnatot, com.sun.jna.ptr.PointerByReference ppixa)
      Original signature : l_ok pixFindHistoPeaksHSV(PIX*, l_int32, l_int32, l_int32, l_int32, l_float32, PTA**, NUMA**, PIXA**)
    • displayHSVColorRange

      Pix displayHSVColorRange(int hval, int sval, int vval, int huehw, int sathw, int nsamp, int factor)
      Original signature : PIX* displayHSVColorRange(l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixConvertRGBToYUV

      Pix pixConvertRGBToYUV(Pix pixd, Pix pixs)
      Original signature : PIX* pixConvertRGBToYUV(PIX*, PIX*)
    • pixConvertYUVToRGB

      Pix pixConvertYUVToRGB(Pix pixd, Pix pixs)
      Original signature : PIX* pixConvertYUVToRGB(PIX*, PIX*)
    • convertRGBToYUV

      int convertRGBToYUV(int rval, int gval, int bval, IntBuffer pyval, IntBuffer puval, IntBuffer pvval)
      Original signature : l_ok convertRGBToYUV(l_int32, l_int32, l_int32, l_int32*, l_int32*, l_int32*)
    • convertYUVToRGB

      int convertYUVToRGB(int yval, int uval, int vval, IntBuffer prval, IntBuffer pgval, IntBuffer pbval)
      Original signature : l_ok convertYUVToRGB(l_int32, l_int32, l_int32, l_int32*, l_int32*, l_int32*)
    • pixcmapConvertRGBToYUV

      int pixcmapConvertRGBToYUV(PixColormap cmap)
      Original signature : l_ok pixcmapConvertRGBToYUV(PIXCMAP*)
    • pixcmapConvertYUVToRGB

      int pixcmapConvertYUVToRGB(PixColormap cmap)
      Original signature : l_ok pixcmapConvertYUVToRGB(PIXCMAP*)
    • pixConvertRGBToXYZ

      FPixa pixConvertRGBToXYZ(Pix pixs)
      Original signature : FPIXA* pixConvertRGBToXYZ(PIX*)
    • fpixaConvertXYZToRGB

      Pix fpixaConvertXYZToRGB(FPixa fpixa)
      Original signature : PIX* fpixaConvertXYZToRGB(FPIXA*)
    • convertRGBToXYZ

      int convertRGBToXYZ(int rval, int gval, int bval, FloatBuffer pfxval, FloatBuffer pfyval, FloatBuffer pfzval)
      Original signature : l_ok convertRGBToXYZ(l_int32, l_int32, l_int32, l_float32*, l_float32*, l_float32*)
    • convertXYZToRGB

      int convertXYZToRGB(float fxval, float fyval, float fzval, int blackout, IntBuffer prval, IntBuffer pgval, IntBuffer pbval)
      Original signature : l_ok convertXYZToRGB(l_float32, l_float32, l_float32, l_int32, l_int32*, l_int32*, l_int32*)
    • fpixaConvertXYZToLAB

      FPixa fpixaConvertXYZToLAB(FPixa fpixas)
      Original signature : FPIXA* fpixaConvertXYZToLAB(FPIXA*)
    • fpixaConvertLABToXYZ

      FPixa fpixaConvertLABToXYZ(FPixa fpixas)
      Original signature : FPIXA* fpixaConvertLABToXYZ(FPIXA*)
    • convertXYZToLAB

      int convertXYZToLAB(float xval, float yval, float zval, FloatBuffer plval, FloatBuffer paval, FloatBuffer pbval)
      Original signature : l_ok convertXYZToLAB(l_float32, l_float32, l_float32, l_float32*, l_float32*, l_float32*)
    • convertLABToXYZ

      int convertLABToXYZ(float lval, float aval, float bval, FloatBuffer pxval, FloatBuffer pyval, FloatBuffer pzval)
      Original signature : l_ok convertLABToXYZ(l_float32, l_float32, l_float32, l_float32*, l_float32*, l_float32*)
    • pixConvertRGBToLAB

      FPixa pixConvertRGBToLAB(Pix pixs)
      Original signature : FPIXA* pixConvertRGBToLAB(PIX*)
    • fpixaConvertLABToRGB

      Pix fpixaConvertLABToRGB(FPixa fpixa)
      Original signature : PIX* fpixaConvertLABToRGB(FPIXA*)
    • convertRGBToLAB

      int convertRGBToLAB(int rval, int gval, int bval, FloatBuffer pflval, FloatBuffer pfaval, FloatBuffer pfbval)
      Original signature : l_ok convertRGBToLAB(l_int32, l_int32, l_int32, l_float32*, l_float32*, l_float32*)
    • convertLABToRGB

      int convertLABToRGB(float flval, float faval, float fbval, IntBuffer prval, IntBuffer pgval, IntBuffer pbval)
      Original signature : l_ok convertLABToRGB(l_float32, l_float32, l_float32, l_int32*, l_int32*, l_int32*)
    • pixMakeGamutRGB

      Pix pixMakeGamutRGB(int scale)
      Original signature : PIX* pixMakeGamutRGB(l_int32)
    • pixEqual

      int pixEqual(Pix pix1, Pix pix2, IntBuffer psame)
      Original signature : l_ok pixEqual(PIX*, PIX*, l_int32*)
    • pixEqualWithAlpha

      int pixEqualWithAlpha(Pix pix1, Pix pix2, int use_alpha, IntBuffer psame)
      Original signature : l_ok pixEqualWithAlpha(PIX*, PIX*, l_int32, l_int32*)
    • pixEqualWithCmap

      int pixEqualWithCmap(Pix pix1, Pix pix2, IntBuffer psame)
      Original signature : l_ok pixEqualWithCmap(PIX*, PIX*, l_int32*)
    • cmapEqual

      int cmapEqual(PixColormap cmap1, PixColormap cmap2, int ncomps, IntBuffer psame)
      Original signature : l_ok cmapEqual(PIXCMAP*, PIXCMAP*, l_int32, l_int32*)
    • pixUsesCmapColor

      int pixUsesCmapColor(Pix pixs, IntBuffer pcolor)
      Original signature : l_ok pixUsesCmapColor(PIX*, l_int32*)
    • pixCorrelationBinary

      int pixCorrelationBinary(Pix pix1, Pix pix2, FloatBuffer pval)
      Original signature : l_ok pixCorrelationBinary(PIX*, PIX*, l_float32*)
    • pixDisplayDiffBinary

      Pix pixDisplayDiffBinary(Pix pix1, Pix pix2)
      Original signature : PIX* pixDisplayDiffBinary(PIX*, PIX*)
    • pixCompareBinary

      int pixCompareBinary(Pix pix1, Pix pix2, int comptype, FloatBuffer pfract, com.sun.jna.ptr.PointerByReference ppixdiff)
      Original signature : l_ok pixCompareBinary(PIX*, PIX*, l_int32, l_float32*, PIX**)
    • pixCompareBinary

      int pixCompareBinary(Pix pix1, Pix pix2, int comptype, com.sun.jna.ptr.FloatByReference pfract, com.sun.jna.ptr.PointerByReference ppixdiff)
      Original signature : l_ok pixCompareBinary(PIX*, PIX*, l_int32, l_float32*, PIX**)
    • pixCompareGrayOrRGB

      int pixCompareGrayOrRGB(Pix pix1, Pix pix2, int comptype, int plottype, IntBuffer psame, FloatBuffer pdiff, FloatBuffer prmsdiff, com.sun.jna.ptr.PointerByReference ppixdiff)
      Original signature : l_ok pixCompareGrayOrRGB(PIX*, PIX*, l_int32, l_int32, l_int32*, l_float32*, l_float32*, PIX**)
    • pixCompareGrayOrRGB

      int pixCompareGrayOrRGB(Pix pix1, Pix pix2, int comptype, int plottype, com.sun.jna.ptr.IntByReference psame, com.sun.jna.ptr.FloatByReference pdiff, com.sun.jna.ptr.FloatByReference prmsdiff, com.sun.jna.ptr.PointerByReference ppixdiff)
      Original signature : l_ok pixCompareGrayOrRGB(PIX*, PIX*, l_int32, l_int32, l_int32*, l_float32*, l_float32*, PIX**)
    • pixCompareGray

      int pixCompareGray(Pix pix1, Pix pix2, int comptype, int plottype, IntBuffer psame, FloatBuffer pdiff, FloatBuffer prmsdiff, com.sun.jna.ptr.PointerByReference ppixdiff)
      Original signature : l_ok pixCompareGray(PIX*, PIX*, l_int32, l_int32, l_int32*, l_float32*, l_float32*, PIX**)
    • pixCompareGray

      int pixCompareGray(Pix pix1, Pix pix2, int comptype, int plottype, com.sun.jna.ptr.IntByReference psame, com.sun.jna.ptr.FloatByReference pdiff, com.sun.jna.ptr.FloatByReference prmsdiff, com.sun.jna.ptr.PointerByReference ppixdiff)
      Original signature : l_ok pixCompareGray(PIX*, PIX*, l_int32, l_int32, l_int32*, l_float32*, l_float32*, PIX**)
    • pixCompareRGB

      int pixCompareRGB(Pix pix1, Pix pix2, int comptype, int plottype, IntBuffer psame, FloatBuffer pdiff, FloatBuffer prmsdiff, com.sun.jna.ptr.PointerByReference ppixdiff)
      Original signature : l_ok pixCompareRGB(PIX*, PIX*, l_int32, l_int32, l_int32*, l_float32*, l_float32*, PIX**)
    • pixCompareRGB

      int pixCompareRGB(Pix pix1, Pix pix2, int comptype, int plottype, com.sun.jna.ptr.IntByReference psame, com.sun.jna.ptr.FloatByReference pdiff, com.sun.jna.ptr.FloatByReference prmsdiff, com.sun.jna.ptr.PointerByReference ppixdiff)
      Original signature : l_ok pixCompareRGB(PIX*, PIX*, l_int32, l_int32, l_int32*, l_float32*, l_float32*, PIX**)
    • pixColorFill

      Pix pixColorFill(Pix pixs, int minmax, int maxdiff, int smooth, int minarea, int debug)
      Original signature : PIX* pixColorFill(PIX*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixCompareTiled

      int pixCompareTiled(Pix pix1, Pix pix2, int sx, int sy, int type, com.sun.jna.ptr.PointerByReference ppixdiff)
      Original signature : l_ok pixCompareTiled(PIX*, PIX*, l_int32, l_int32, l_int32, PIX**)
    • pixCompareRankDifference

      Numa pixCompareRankDifference(Pix pix1, Pix pix2, int factor)
      Original signature : NUMA* pixCompareRankDifference(PIX*, PIX*, l_int32)
    • pixTestForSimilarity

      int pixTestForSimilarity(Pix pix1, Pix pix2, int factor, int mindiff, float maxfract, float maxave, IntBuffer psimilar, int details)
      Original signature : l_ok pixTestForSimilarity(PIX*, PIX*, l_int32, l_int32, l_float32, l_float32, l_int32*, l_int32)
    • pixGetDifferenceStats

      int pixGetDifferenceStats(Pix pix1, Pix pix2, int factor, int mindiff, FloatBuffer pfractdiff, FloatBuffer pavediff, int details)
      Original signature : l_ok pixGetDifferenceStats(PIX*, PIX*, l_int32, l_int32, l_float32*, l_float32*, l_int32)
    • pixGetDifferenceHistogram

      Numa pixGetDifferenceHistogram(Pix pix1, Pix pix2, int factor)
      Original signature : NUMA* pixGetDifferenceHistogram(PIX*, PIX*, l_int32)
    • pixGetPerceptualDiff

      int pixGetPerceptualDiff(Pix pixs1, Pix pixs2, int sampling, int dilation, int mindiff, FloatBuffer pfract, com.sun.jna.ptr.PointerByReference ppixdiff1, com.sun.jna.ptr.PointerByReference ppixdiff2)
      Original signature : l_ok pixGetPerceptualDiff(PIX*, PIX*, l_int32, l_int32, l_int32, l_float32*, PIX**, PIX**)
    • pixGetPerceptualDiff

      int pixGetPerceptualDiff(Pix pixs1, Pix pixs2, int sampling, int dilation, int mindiff, com.sun.jna.ptr.FloatByReference pfract, com.sun.jna.ptr.PointerByReference ppixdiff1, com.sun.jna.ptr.PointerByReference ppixdiff2)
      Original signature : l_ok pixGetPerceptualDiff(PIX*, PIX*, l_int32, l_int32, l_int32, l_float32*, PIX**, PIX**)
    • pixGetPSNR

      int pixGetPSNR(Pix pix1, Pix pix2, int factor, FloatBuffer ppsnr)
      Original signature : l_ok pixGetPSNR(PIX*, PIX*, l_int32, l_float32*)
    • pixaComparePhotoRegionsByHisto

      int pixaComparePhotoRegionsByHisto(Pixa pixa, float minratio, float textthresh, int factor, int n, float simthresh, com.sun.jna.ptr.PointerByReference pnai, com.sun.jna.ptr.PointerByReference pscores, com.sun.jna.ptr.PointerByReference ppixd, int debug)
      Original signature : l_ok pixaComparePhotoRegionsByHisto(PIXA*, l_float32, l_float32, l_int32, l_int32, l_float32, NUMA**, l_float32**, PIX**, l_int32)
    • pixComparePhotoRegionsByHisto

      int pixComparePhotoRegionsByHisto(Pix pix1, Pix pix2, Box box1, Box box2, float minratio, int factor, int n, FloatBuffer pscore, int debugflag)
      Original signature : l_ok pixComparePhotoRegionsByHisto(PIX*, PIX*, BOX*, BOX*, l_float32, l_int32, l_int32, l_float32*, l_int32)
    • pixGenPhotoHistos

      int pixGenPhotoHistos(Pix pixs, Box box, int factor, float thresh, int n, com.sun.jna.ptr.PointerByReference pnaa, IntBuffer pw, IntBuffer ph, int debugindex)
      Original signature : l_ok pixGenPhotoHistos(PIX*, BOX*, l_int32, l_float32, l_int32, NUMAA**, l_int32*, l_int32*, l_int32)
    • pixGenPhotoHistos

      int pixGenPhotoHistos(Pix pixs, Box box, int factor, float thresh, int n, com.sun.jna.ptr.PointerByReference pnaa, com.sun.jna.ptr.IntByReference pw, com.sun.jna.ptr.IntByReference ph, int debugindex)
      Original signature : l_ok pixGenPhotoHistos(PIX*, BOX*, l_int32, l_float32, l_int32, NUMAA**, l_int32*, l_int32*, l_int32)
    • pixPadToCenterCentroid

      Pix pixPadToCenterCentroid(Pix pixs, int factor)
      Original signature : PIX* pixPadToCenterCentroid(PIX*, l_int32)
    • pixCentroid8

      int pixCentroid8(Pix pixs, int factor, FloatBuffer pcx, FloatBuffer pcy)
      Original signature : l_ok pixCentroid8(PIX*, l_int32, l_float32*, l_float32*)
    • pixDecideIfPhotoImage

      int pixDecideIfPhotoImage(Pix pix, int factor, float thresh, int n, com.sun.jna.ptr.PointerByReference pnaa, Pixa pixadebug)
      Original signature : l_ok pixDecideIfPhotoImage(PIX*, l_int32, l_float32, l_int32, NUMAA**, PIXA*)
    • compareTilesByHisto

      int compareTilesByHisto(Numaa naa1, Numaa naa2, float minratio, int w1, int h1, int w2, int h2, FloatBuffer pscore, Pixa pixadebug)
      Original signature : l_ok compareTilesByHisto(NUMAA*, NUMAA*, l_float32, l_int32, l_int32, l_int32, l_int32, l_float32*, PIXA*)
    • pixCompareGrayByHisto

      int pixCompareGrayByHisto(Pix pix1, Pix pix2, Box box1, Box box2, float minratio, int maxgray, int factor, int n, FloatBuffer pscore, int debugflag)
      Original signature : l_ok pixCompareGrayByHisto(PIX*, PIX*, BOX*, BOX*, l_float32, l_int32, l_int32, l_int32, l_float32*, l_int32)
    • pixCropAlignedToCentroid

      int pixCropAlignedToCentroid(Pix pix1, Pix pix2, int factor, com.sun.jna.ptr.PointerByReference pbox1, com.sun.jna.ptr.PointerByReference pbox2)
      Original signature : l_ok pixCropAlignedToCentroid(PIX*, PIX*, l_int32, BOX**, BOX**)
    • l_compressGrayHistograms

      com.sun.jna.Pointer l_compressGrayHistograms(Numaa naa, int w, int h, NativeSizeByReference psize)
      Original signature : l_uint8* l_compressGrayHistograms(NUMAA*, l_int32, l_int32, size_t*)
    • l_uncompressGrayHistograms

      Numaa l_uncompressGrayHistograms(ByteBuffer bytea, NativeSize size, IntBuffer pw, IntBuffer ph)
      Original signature : NUMAA* l_uncompressGrayHistograms(l_uint8*, size_t, l_int32*, l_int32*)
    • pixCompareWithTranslation

      int pixCompareWithTranslation(Pix pix1, Pix pix2, int thresh, IntBuffer pdelx, IntBuffer pdely, FloatBuffer pscore, int debugflag)
      Original signature : l_ok pixCompareWithTranslation(PIX*, PIX*, l_int32, l_int32*, l_int32*, l_float32*, l_int32)
    • pixBestCorrelation

      int 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)
      Original signature : l_ok pixBestCorrelation(PIX*, PIX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32*, l_int32*, l_int32*, l_float32*, l_int32)
    • pixConnComp

      Boxa pixConnComp(Pix pixs, com.sun.jna.ptr.PointerByReference ppixa, int connectivity)
      Original signature : BOXA* pixConnComp(PIX*, PIXA**, l_int32)
    • pixConnCompPixa

      Boxa pixConnCompPixa(Pix pixs, com.sun.jna.ptr.PointerByReference ppixa, int connectivity)
      Original signature : BOXA* pixConnCompPixa(PIX*, PIXA**, l_int32)
    • pixConnCompBB

      Boxa pixConnCompBB(Pix pixs, int connectivity)
      Original signature : BOXA* pixConnCompBB(PIX*, l_int32)
    • pixCountConnComp

      int pixCountConnComp(Pix pixs, int connectivity, IntBuffer pcount)
      Original signature : l_ok pixCountConnComp(PIX*, l_int32, l_int32*)
    • nextOnPixelInRaster

      int nextOnPixelInRaster(Pix pixs, int xstart, int ystart, IntBuffer px, IntBuffer py)
      Original signature : l_int32 nextOnPixelInRaster(PIX*, l_int32, l_int32, l_int32*, l_int32*)
    • pixSeedfillBB

      Box pixSeedfillBB(Pix pixs, L_Stack stack, int x, int y, int connectivity)
      Original signature : BOX* pixSeedfillBB(PIX*, L_STACK*, l_int32, l_int32, l_int32)
    • pixSeedfill4BB

      Box pixSeedfill4BB(Pix pixs, L_Stack stack, int x, int y)
      Original signature : BOX* pixSeedfill4BB(PIX*, L_STACK*, l_int32, l_int32)
    • pixSeedfill8BB

      Box pixSeedfill8BB(Pix pixs, L_Stack stack, int x, int y)
      Original signature : BOX* pixSeedfill8BB(PIX*, L_STACK*, l_int32, l_int32)
    • pixSeedfill

      int pixSeedfill(Pix pixs, L_Stack stack, int x, int y, int connectivity)
      Original signature : l_ok pixSeedfill(PIX*, L_STACK*, l_int32, l_int32, l_int32)
    • pixSeedfill4

      int pixSeedfill4(Pix pixs, L_Stack stack, int x, int y)
      Original signature : l_ok pixSeedfill4(PIX*, L_STACK*, l_int32, l_int32)
    • pixSeedfill8

      int pixSeedfill8(Pix pixs, L_Stack stack, int x, int y)
      Original signature : l_ok pixSeedfill8(PIX*, L_STACK*, l_int32, l_int32)
    • convertFilesTo1bpp

      int convertFilesTo1bpp(String dirin, String substr, int upscaling, int thresh, int firstpage, int npages, String dirout, int outformat)
      Original signature : l_ok convertFilesTo1bpp(const char*, const char*, l_int32, l_int32, l_int32, l_int32, const char*, l_int32)
    • pixBlockconv

      Pix pixBlockconv(Pix pix, int wc, int hc)
      Original signature : PIX* pixBlockconv(PIX*, l_int32, l_int32)
    • pixBlockconvGray

      Pix pixBlockconvGray(Pix pixs, Pix pixacc, int wc, int hc)
      Original signature : PIX* pixBlockconvGray(PIX*, PIX*, l_int32, l_int32)
    • pixBlockconvAccum

      Pix pixBlockconvAccum(Pix pixs)
      Original signature : PIX* pixBlockconvAccum(PIX*)
    • pixBlockconvGrayUnnormalized

      Pix pixBlockconvGrayUnnormalized(Pix pixs, int wc, int hc)
      Original signature : PIX* pixBlockconvGrayUnnormalized(PIX*, l_int32, l_int32)
    • pixBlockconvTiled

      Pix pixBlockconvTiled(Pix pix, int wc, int hc, int nx, int ny)
      Original signature : PIX* pixBlockconvTiled(PIX*, l_int32, l_int32, l_int32, l_int32)
    • pixBlockconvGrayTile

      Pix pixBlockconvGrayTile(Pix pixs, Pix pixacc, int wc, int hc)
      Original signature : PIX* pixBlockconvGrayTile(PIX*, PIX*, l_int32, l_int32)
    • pixWindowedStats

      int pixWindowedStats(Pix pixs, int wc, int hc, int hasborder, com.sun.jna.ptr.PointerByReference ppixm, com.sun.jna.ptr.PointerByReference ppixms, com.sun.jna.ptr.PointerByReference pfpixv, com.sun.jna.ptr.PointerByReference pfpixrv)
      Original signature : l_ok pixWindowedStats(PIX*, l_int32, l_int32, l_int32, PIX**, PIX**, FPIX**, FPIX**)
    • pixWindowedMean

      Pix pixWindowedMean(Pix pixs, int wc, int hc, int hasborder, int normflag)
      Original signature : PIX* pixWindowedMean(PIX*, l_int32, l_int32, l_int32, l_int32)
    • pixWindowedMeanSquare

      Pix pixWindowedMeanSquare(Pix pixs, int wc, int hc, int hasborder)
      Original signature : PIX* pixWindowedMeanSquare(PIX*, l_int32, l_int32, l_int32)
    • pixWindowedVariance

      int pixWindowedVariance(Pix pixm, Pix pixms, com.sun.jna.ptr.PointerByReference pfpixv, com.sun.jna.ptr.PointerByReference pfpixrv)
      Original signature : l_ok pixWindowedVariance(PIX*, PIX*, FPIX**, FPIX**)
    • pixMeanSquareAccum

      DPix pixMeanSquareAccum(Pix pixs)
      Original signature : DPIX* pixMeanSquareAccum(PIX*)
    • pixBlockrank

      Pix pixBlockrank(Pix pixs, Pix pixacc, int wc, int hc, float rank)
      Original signature : PIX* pixBlockrank(PIX*, PIX*, l_int32, l_int32, l_float32)
    • pixBlocksum

      Pix pixBlocksum(Pix pixs, Pix pixacc, int wc, int hc)
      Original signature : PIX* pixBlocksum(PIX*, PIX*, l_int32, l_int32)
    • pixCensusTransform

      Pix pixCensusTransform(Pix pixs, int halfsize, Pix pixacc)
      Original signature : PIX* pixCensusTransform(PIX*, l_int32, PIX*)
    • pixConvolve

      Pix pixConvolve(Pix pixs, L_Kernel kel, int outdepth, int normflag)
      Original signature : PIX* pixConvolve(PIX*, L_KERNEL*, l_int32, l_int32)
    • pixConvolveSep

      Pix pixConvolveSep(Pix pixs, L_Kernel kelx, L_Kernel kely, int outdepth, int normflag)
      Original signature : PIX* pixConvolveSep(PIX*, L_KERNEL*, L_KERNEL*, l_int32, l_int32)
    • pixConvolveRGB

      Pix pixConvolveRGB(Pix pixs, L_Kernel kel)
      Original signature : PIX* pixConvolveRGB(PIX*, L_KERNEL*)
    • pixConvolveRGBSep

      Pix pixConvolveRGBSep(Pix pixs, L_Kernel kelx, L_Kernel kely)
      Original signature : PIX* pixConvolveRGBSep(PIX*, L_KERNEL*, L_KERNEL*)
    • fpixConvolve

      FPix fpixConvolve(FPix fpixs, L_Kernel kel, int normflag)
      Original signature : FPIX* fpixConvolve(FPIX*, L_KERNEL*, l_int32)
    • fpixConvolveSep

      FPix fpixConvolveSep(FPix fpixs, L_Kernel kelx, L_Kernel kely, int normflag)
      Original signature : FPIX* fpixConvolveSep(FPIX*, L_KERNEL*, L_KERNEL*, l_int32)
    • pixConvolveWithBias

      Pix pixConvolveWithBias(Pix pixs, L_Kernel kel1, L_Kernel kel2, int force8, IntBuffer pbias)
      Original signature : PIX* pixConvolveWithBias(PIX*, L_KERNEL*, L_KERNEL*, l_int32, l_int32*)
    • l_setConvolveSampling

      void l_setConvolveSampling(int xfact, int yfact)
      Original signature : void l_setConvolveSampling(l_int32, l_int32)
    • pixAddGaussianNoise

      Pix pixAddGaussianNoise(Pix pixs, float stdev)
      Original signature : PIX* pixAddGaussianNoise(PIX*, l_float32)
    • gaussDistribSampling

      float gaussDistribSampling()
      Original signature : l_float32 gaussDistribSampling()
    • dewarpCreate

      L_Dewarp dewarpCreate(Pix pixs, int pageno)
      Original signature : L_DEWARP* dewarpCreate(PIX*, l_int32)
    • dewarpCreateRef

      L_Dewarp dewarpCreateRef(int pageno, int refpage)
      Original signature : L_DEWARP* dewarpCreateRef(l_int32, l_int32)
    • dewarpDestroy

      void dewarpDestroy(com.sun.jna.ptr.PointerByReference pdew)
      Original signature : void dewarpDestroy(L_DEWARP**)
    • dewarpaCreate

      L_Dewarpa dewarpaCreate(int nptrs, int sampling, int redfactor, int minlines, int maxdist)
      Original signature : L_DEWARPA* dewarpaCreate(l_int32, l_int32, l_int32, l_int32, l_int32)
    • dewarpaCreateFromPixacomp

      L_Dewarpa dewarpaCreateFromPixacomp(PixaComp pixac, int useboth, int sampling, int minlines, int maxdist)
      Original signature : L_DEWARPA* dewarpaCreateFromPixacomp(PIXAC*, l_int32, l_int32, l_int32, l_int32)
    • dewarpaDestroy

      void dewarpaDestroy(com.sun.jna.ptr.PointerByReference pdewa)
      Original signature : void dewarpaDestroy(L_DEWARPA**)
    • dewarpaDestroyDewarp

      int dewarpaDestroyDewarp(L_Dewarpa dewa, int pageno)
      Original signature : l_ok dewarpaDestroyDewarp(L_DEWARPA*, l_int32)
    • dewarpaInsertDewarp

      int dewarpaInsertDewarp(L_Dewarpa dewa, L_Dewarp dew)
      Original signature : l_ok dewarpaInsertDewarp(L_DEWARPA*, L_DEWARP*)
    • dewarpaGetDewarp

      L_Dewarp dewarpaGetDewarp(L_Dewarpa dewa, int index)
      Original signature : L_DEWARP* dewarpaGetDewarp(L_DEWARPA*, l_int32)
    • dewarpaSetCurvatures

      int dewarpaSetCurvatures(L_Dewarpa dewa, int max_linecurv, int min_diff_linecurv, int max_diff_linecurv, int max_edgecurv, int max_diff_edgecurv, int max_edgeslope)
      Original signature : l_ok dewarpaSetCurvatures(L_DEWARPA*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32)
    • dewarpaUseBothArrays

      int dewarpaUseBothArrays(L_Dewarpa dewa, int useboth)
      Original signature : l_ok dewarpaUseBothArrays(L_DEWARPA*, l_int32)
    • dewarpaSetCheckColumns

      int dewarpaSetCheckColumns(L_Dewarpa dewa, int check_columns)
      Original signature : l_ok dewarpaSetCheckColumns(L_DEWARPA*, l_int32)
    • dewarpaSetMaxDistance

      int dewarpaSetMaxDistance(L_Dewarpa dewa, int maxdist)
      Original signature : l_ok dewarpaSetMaxDistance(L_DEWARPA*, l_int32)
    • dewarpRead

      L_Dewarp dewarpRead(String filename)
      Original signature : L_DEWARP* dewarpRead(const char*)
    • dewarpReadMem

      L_Dewarp dewarpReadMem(ByteBuffer data, NativeSize size)
      Original signature : L_DEWARP* dewarpReadMem(const l_uint8*, size_t)
    • dewarpWrite

      int dewarpWrite(String filename, L_Dewarp dew)
      Original signature : l_ok dewarpWrite(const char*, L_DEWARP*)
    • dewarpWriteMem

      int dewarpWriteMem(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, L_Dewarp dew)
      Original signature : l_ok dewarpWriteMem(l_uint8**, size_t*, L_DEWARP*)
    • dewarpaRead

      L_Dewarpa dewarpaRead(String filename)
      Original signature : L_DEWARPA* dewarpaRead(const char*)
    • dewarpaReadMem

      L_Dewarpa dewarpaReadMem(ByteBuffer data, NativeSize size)
      Original signature : L_DEWARPA* dewarpaReadMem(const l_uint8*, size_t)
    • dewarpaWrite

      int dewarpaWrite(String filename, L_Dewarpa dewa)
      Original signature : l_ok dewarpaWrite(const char*, L_DEWARPA*)
    • dewarpaWriteMem

      int dewarpaWriteMem(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, L_Dewarpa dewa)
      Original signature : l_ok dewarpaWriteMem(l_uint8**, size_t*, L_DEWARPA*)
    • dewarpBuildPageModel

      int dewarpBuildPageModel(L_Dewarp dew, String debugfile)
      Original signature : l_ok dewarpBuildPageModel(L_DEWARP*, const char*)
    • dewarpFindVertDisparity

      int dewarpFindVertDisparity(L_Dewarp dew, Ptaa ptaa, int rotflag)
      Original signature : l_ok dewarpFindVertDisparity(L_DEWARP*, PTAA*, l_int32)
    • dewarpFindHorizDisparity

      int dewarpFindHorizDisparity(L_Dewarp dew, Ptaa ptaa)
      Original signature : l_ok dewarpFindHorizDisparity(L_DEWARP*, PTAA*)
    • dewarpGetTextlineCenters

      Ptaa dewarpGetTextlineCenters(Pix pixs, int debugflag)
      Original signature : PTAA* dewarpGetTextlineCenters(PIX*, l_int32)
    • dewarpRemoveShortLines

      Ptaa dewarpRemoveShortLines(Pix pixs, Ptaa ptaas, float fract, int debugflag)
      Original signature : PTAA* dewarpRemoveShortLines(PIX*, PTAA*, l_float32, l_int32)
    • dewarpFindHorizSlopeDisparity

      int dewarpFindHorizSlopeDisparity(L_Dewarp dew, Pix pixb, float fractthresh, int parity)
      Original signature : l_ok dewarpFindHorizSlopeDisparity(L_DEWARP*, PIX*, l_float32, l_int32)
    • dewarpBuildLineModel

      int dewarpBuildLineModel(L_Dewarp dew, int opensize, String debugfile)
      Original signature : l_ok dewarpBuildLineModel(L_DEWARP*, l_int32, const char*)
    • dewarpaModelStatus

      int dewarpaModelStatus(L_Dewarpa dewa, int pageno, IntBuffer pvsuccess, IntBuffer phsuccess)
      Original signature : l_ok dewarpaModelStatus(L_DEWARPA*, l_int32, l_int32*, l_int32*)
    • dewarpaApplyDisparity

      int dewarpaApplyDisparity(L_Dewarpa dewa, int pageno, Pix pixs, int grayin, int x, int y, com.sun.jna.ptr.PointerByReference ppixd, String debugfile)
      Original signature : l_ok dewarpaApplyDisparity(L_DEWARPA*, l_int32, PIX*, l_int32, l_int32, l_int32, PIX**, const char*)
    • dewarpaApplyDisparity

      int dewarpaApplyDisparity(L_Dewarpa dewa, int pageno, Pix pixs, int grayin, int x, int y, com.sun.jna.ptr.PointerByReference ppixd, com.sun.jna.Pointer debugfile)
      Original signature : l_ok dewarpaApplyDisparity(L_DEWARPA*, l_int32, PIX*, l_int32, l_int32, l_int32, PIX**, const char*)
    • dewarpaApplyDisparityBoxa

      int dewarpaApplyDisparityBoxa(L_Dewarpa dewa, int pageno, Pix pixs, Boxa boxas, int mapdir, int x, int y, com.sun.jna.ptr.PointerByReference pboxad, String debugfile)
      Original signature : l_ok dewarpaApplyDisparityBoxa(L_DEWARPA*, l_int32, PIX*, BOXA*, l_int32, l_int32, l_int32, BOXA**, const char*)
    • dewarpaApplyDisparityBoxa

      int dewarpaApplyDisparityBoxa(L_Dewarpa dewa, int pageno, Pix pixs, Boxa boxas, int mapdir, int x, int y, com.sun.jna.ptr.PointerByReference pboxad, com.sun.jna.Pointer debugfile)
      Original signature : l_ok dewarpaApplyDisparityBoxa(L_DEWARPA*, l_int32, PIX*, BOXA*, l_int32, l_int32, l_int32, BOXA**, const char*)
    • dewarpMinimize

      int dewarpMinimize(L_Dewarp dew)
      Original signature : l_ok dewarpMinimize(L_DEWARP*)
    • dewarpPopulateFullRes

      int dewarpPopulateFullRes(L_Dewarp dew, Pix pix, int x, int y)
      Original signature : l_ok dewarpPopulateFullRes(L_DEWARP*, PIX*, l_int32, l_int32)
    • dewarpSinglePage

      int dewarpSinglePage(Pix pixs, int thresh, int adaptive, int useboth, int check_columns, com.sun.jna.ptr.PointerByReference ppixd, com.sun.jna.ptr.PointerByReference pdewa, int debug)
      Original signature : l_ok dewarpSinglePage(PIX*, l_int32, l_int32, l_int32, l_int32, PIX**, L_DEWARPA**, l_int32)
    • dewarpSinglePageInit

      int dewarpSinglePageInit(Pix pixs, int thresh, int adaptive, int useboth, int check_columns, com.sun.jna.ptr.PointerByReference ppixb, com.sun.jna.ptr.PointerByReference pdewa)
      Original signature : l_ok dewarpSinglePageInit(PIX*, l_int32, l_int32, l_int32, l_int32, PIX**, L_DEWARPA**)
    • dewarpSinglePageRun

      int dewarpSinglePageRun(Pix pixs, Pix pixb, L_Dewarpa dewa, com.sun.jna.ptr.PointerByReference ppixd, int debug)
      Original signature : l_ok dewarpSinglePageRun(PIX*, PIX*, L_DEWARPA*, PIX**, l_int32)
    • dewarpaListPages

      int dewarpaListPages(L_Dewarpa dewa)
      Original signature : l_ok dewarpaListPages(L_DEWARPA*)
    • dewarpaSetValidModels

      int dewarpaSetValidModels(L_Dewarpa dewa, int notests, int debug)
      Original signature : l_ok dewarpaSetValidModels(L_DEWARPA*, l_int32, l_int32)
    • dewarpaInsertRefModels

      int dewarpaInsertRefModels(L_Dewarpa dewa, int notests, int debug)
      Original signature : l_ok dewarpaInsertRefModels(L_DEWARPA*, l_int32, l_int32)
    • dewarpaStripRefModels

      int dewarpaStripRefModels(L_Dewarpa dewa)
      Original signature : l_ok dewarpaStripRefModels(L_DEWARPA*)
    • dewarpaRestoreModels

      int dewarpaRestoreModels(L_Dewarpa dewa)
      Original signature : l_ok dewarpaRestoreModels(L_DEWARPA*)
    • dewarpaModelStats

      int dewarpaModelStats(L_Dewarpa dewa, IntBuffer pnnone, IntBuffer pnvsuccess, IntBuffer pnvvalid, IntBuffer pnhsuccess, IntBuffer pnhvalid, IntBuffer pnref)
      Original signature : l_ok dewarpaModelStats(L_DEWARPA*, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*)
    • dewarpaShowArrays

      int dewarpaShowArrays(L_Dewarpa dewa, float scalefact, int first, int last)
      Original signature : l_ok dewarpaShowArrays(L_DEWARPA*, l_float32, l_int32, l_int32)
    • dewarpDebug

      int dewarpDebug(L_Dewarp dew, String subdirs, int index)
      Original signature : l_ok dewarpDebug(L_DEWARP*, const char*, l_int32)
    • dewarpShowResults

      int dewarpShowResults(L_Dewarpa dewa, Sarray sa, Boxa boxa, int firstpage, int lastpage, String pdfout)
      Original signature : l_ok dewarpShowResults(L_DEWARPA*, SARRAY*, BOXA*, l_int32, l_int32, const char*)
    • l_dnaaCreateFull

      L_Dnaa l_dnaaCreateFull(int nptr, int n)
      Original signature : L_DNAA* l_dnaaCreateFull(l_int32, l_int32)
    • l_dnaaTruncate

      int l_dnaaTruncate(L_Dnaa daa)
      Original signature : l_ok l_dnaaTruncate(L_DNAA*)
    • l_dnaaFlattenToDna

      L_Dna l_dnaaFlattenToDna(L_Dnaa daa)
      Original signature : L_DNA* l_dnaaFlattenToDna(L_DNAA*)
    • l_asetCreateFromDna

      L_Rbtree l_asetCreateFromDna(L_Dna da)
      Original signature : L_ASET* l_asetCreateFromDna(L_DNA*)
    • l_dnaDiffAdjValues

      L_Dna l_dnaDiffAdjValues(L_Dna das)
      Original signature : L_DNA* l_dnaDiffAdjValues(L_DNA*)
    • l_dnaHashCreate

      L_DnaHash l_dnaHashCreate(int nbuckets, int initsize)
      Original signature : L_DNAHASH* l_dnaHashCreate(l_int32, l_int32)
    • l_dnaHashDestroy

      void l_dnaHashDestroy(com.sun.jna.ptr.PointerByReference pdahash)
      Original signature : void l_dnaHashDestroy(L_DNAHASH**)
    • l_dnaHashGetCount

      int l_dnaHashGetCount(L_DnaHash dahash)
      Original signature : l_int32 l_dnaHashGetCount(L_DNAHASH*)
    • l_dnaHashGetTotalCount

      int l_dnaHashGetTotalCount(L_DnaHash dahash)
      Original signature : l_int32 l_dnaHashGetTotalCount(L_DNAHASH*)
    • l_dnaHashGetDna

      L_Dna l_dnaHashGetDna(L_DnaHash dahash, long key, int copyflag)
      Original signature : L_DNA* l_dnaHashGetDna(L_DNAHASH*, l_uint64, l_int32)
    • l_dnaHashAdd

      int l_dnaHashAdd(L_DnaHash dahash, long key, double value)
      Original signature : l_ok l_dnaHashAdd(L_DNAHASH*, l_uint64, l_float64)
    • l_dnaHashCreateFromDna

      L_DnaHash l_dnaHashCreateFromDna(L_Dna da)
      Original signature : L_DNAHASH* l_dnaHashCreateFromDna(L_DNA*)
    • l_dnaRemoveDupsByHash

      int l_dnaRemoveDupsByHash(L_Dna das, com.sun.jna.ptr.PointerByReference pdad, com.sun.jna.ptr.PointerByReference pdahash)
      Original signature : l_ok l_dnaRemoveDupsByHash(L_DNA*, L_DNA**, L_DNAHASH**)
    • l_dnaMakeHistoByHash

      int l_dnaMakeHistoByHash(L_Dna das, com.sun.jna.ptr.PointerByReference pdahash, com.sun.jna.ptr.PointerByReference pdav, com.sun.jna.ptr.PointerByReference pdac)
      Original signature : l_ok l_dnaMakeHistoByHash(L_DNA*, L_DNAHASH**, L_DNA**, L_DNA**)
    • l_dnaIntersectionByHash

      L_Dna l_dnaIntersectionByHash(L_Dna da1, L_Dna da2)
      Original signature : L_DNA* l_dnaIntersectionByHash(L_DNA*, L_DNA*)
    • l_dnaFindValByHash

      int l_dnaFindValByHash(L_Dna da, L_DnaHash dahash, double val, IntBuffer pindex)
      Original signature : l_ok l_dnaFindValByHash(L_DNA*, L_DNAHASH*, l_float64, l_int32*)
    • pixMorphDwa_2

      Pix pixMorphDwa_2(Pix pixd, Pix pixs, int operation, ByteBuffer selname)
      Original signature : PIX* pixMorphDwa_2(PIX*, PIX*, l_int32, char*)
    • pixFMorphopGen_2

      Pix pixFMorphopGen_2(Pix pixd, Pix pixs, int operation, ByteBuffer selname)
      Original signature : PIX* pixFMorphopGen_2(PIX*, PIX*, l_int32, char*)
    • fmorphopgen_low_2

      int fmorphopgen_low_2(IntBuffer datad, int w, int h, int wpld, IntBuffer datas, int wpls, int index)
      Original signature : l_int32 fmorphopgen_low_2(l_uint32*, l_int32, l_int32, l_int32, l_uint32*, l_int32, l_int32)
    • pixSobelEdgeFilter

      Pix pixSobelEdgeFilter(Pix pixs, int orientflag)
      Original signature : PIX* pixSobelEdgeFilter(PIX*, l_int32)
    • pixTwoSidedEdgeFilter

      Pix pixTwoSidedEdgeFilter(Pix pixs, int orientflag)
      Original signature : PIX* pixTwoSidedEdgeFilter(PIX*, l_int32)
    • pixMeasureEdgeSmoothness

      int pixMeasureEdgeSmoothness(Pix pixs, int side, int minjump, int minreversal, FloatBuffer pjpl, FloatBuffer pjspl, FloatBuffer prpl, String debugfile)
      Original signature : l_ok pixMeasureEdgeSmoothness(PIX*, l_int32, l_int32, l_int32, l_float32*, l_float32*, l_float32*, const char*)
    • pixGetEdgeProfile

      Numa pixGetEdgeProfile(Pix pixs, int side, String debugfile)
      Original signature : NUMA* pixGetEdgeProfile(PIX*, l_int32, const char*)
    • pixGetLastOffPixelInRun

      int pixGetLastOffPixelInRun(Pix pixs, int x, int y, int direction, IntBuffer ploc)
      Original signature : l_int32 pixGetLastOffPixelInRun(PIX*, l_int32, l_int32, l_int32, l_int32*)
    • pixGetLastOnPixelInRun

      int pixGetLastOnPixelInRun(Pix pixs, int x, int y, int direction, IntBuffer ploc)
      Original signature : l_int32 pixGetLastOnPixelInRun(PIX*, l_int32, l_int32, l_int32, l_int32*)
    • encodeBase64

      com.sun.jna.Pointer encodeBase64(ByteBuffer inarray, int insize, IntBuffer poutsize)
      Original signature : char* encodeBase64(l_uint8*, l_int32, l_int32*)
    • decodeBase64

      com.sun.jna.Pointer decodeBase64(String inarray, int insize, IntBuffer poutsize)
      Original signature : l_uint8* decodeBase64(const char*, l_int32, l_int32*)
    • encodeAscii85

      com.sun.jna.Pointer encodeAscii85(ByteBuffer inarray, NativeSize insize, NativeSizeByReference poutsize)
      Original signature : char* encodeAscii85(const l_uint8*, size_t, size_t*)
    • decodeAscii85

      com.sun.jna.Pointer decodeAscii85(String inarray, NativeSize insize, NativeSizeByReference poutsize)
      Original signature : l_uint8* decodeAscii85(const char*, size_t, size_t*)
    • encodeAscii85WithComp

      com.sun.jna.Pointer encodeAscii85WithComp(ByteBuffer indata, NativeSize insize, NativeSizeByReference poutsize)
      Original signature : char* encodeAscii85WithComp(const l_uint8*, size_t, size_t*)
    • decodeAscii85WithComp

      com.sun.jna.Pointer decodeAscii85WithComp(String instr, NativeSize insize, NativeSizeByReference poutsize)
      Original signature : l_uint8* decodeAscii85WithComp(const char*, size_t, size_t*)
    • reformatPacked64

      com.sun.jna.Pointer reformatPacked64(String inarray, int insize, int leadspace, int linechars, int addquotes, IntBuffer poutsize)
      Original signature : char* reformatPacked64(const char*, l_int32, l_int32, l_int32, l_int32, l_int32*)
    • pixGammaTRC

      Pix pixGammaTRC(Pix pixd, Pix pixs, float gamma, int minval, int maxval)
      Original signature : PIX* pixGammaTRC(PIX*, PIX*, l_float32, l_int32, l_int32)
    • pixGammaTRCMasked

      Pix pixGammaTRCMasked(Pix pixd, Pix pixs, Pix pixm, float gamma, int minval, int maxval)
      Original signature : PIX* pixGammaTRCMasked(PIX*, PIX*, PIX*, l_float32, l_int32, l_int32)
    • pixGammaTRCWithAlpha

      Pix pixGammaTRCWithAlpha(Pix pixd, Pix pixs, float gamma, int minval, int maxval)
      Original signature : PIX* pixGammaTRCWithAlpha(PIX*, PIX*, l_float32, l_int32, l_int32)
    • numaGammaTRC

      Numa numaGammaTRC(float gamma, int minval, int maxval)
      Original signature : NUMA* numaGammaTRC(l_float32, l_int32, l_int32)
    • pixContrastTRC

      Pix pixContrastTRC(Pix pixd, Pix pixs, float factor)
      Original signature : PIX* pixContrastTRC(PIX*, PIX*, l_float32)
    • pixContrastTRCMasked

      Pix pixContrastTRCMasked(Pix pixd, Pix pixs, Pix pixm, float factor)
      Original signature : PIX* pixContrastTRCMasked(PIX*, PIX*, PIX*, l_float32)
    • numaContrastTRC

      Numa numaContrastTRC(float factor)
      Original signature : NUMA* numaContrastTRC(l_float32)
    • pixEqualizeTRC

      Pix pixEqualizeTRC(Pix pixd, Pix pixs, float fract, int factor)
      Original signature : PIX* pixEqualizeTRC(PIX*, PIX*, l_float32, l_int32)
    • numaEqualizeTRC

      Numa numaEqualizeTRC(Pix pix, float fract, int factor)
      Original signature : NUMA* numaEqualizeTRC(PIX*, l_float32, l_int32)
    • pixTRCMap

      int pixTRCMap(Pix pixs, Pix pixm, Numa na)
      Original signature : l_int32 pixTRCMap(PIX*, PIX*, NUMA*)
    • pixTRCMapGeneral

      int pixTRCMapGeneral(Pix pixs, Pix pixm, Numa nar, Numa nag, Numa nab)
      Original signature : l_int32 pixTRCMapGeneral(PIX*, PIX*, NUMA*, NUMA*, NUMA*)
    • pixUnsharpMasking

      Pix pixUnsharpMasking(Pix pixs, int halfwidth, float fract)
      Original signature : PIX* pixUnsharpMasking(PIX*, l_int32, l_float32)
    • pixUnsharpMaskingGray

      Pix pixUnsharpMaskingGray(Pix pixs, int halfwidth, float fract)
      Original signature : PIX* pixUnsharpMaskingGray(PIX*, l_int32, l_float32)
    • pixUnsharpMaskingFast

      Pix pixUnsharpMaskingFast(Pix pixs, int halfwidth, float fract, int direction)
      Original signature : PIX* pixUnsharpMaskingFast(PIX*, l_int32, l_float32, l_int32)
    • pixUnsharpMaskingGrayFast

      Pix pixUnsharpMaskingGrayFast(Pix pixs, int halfwidth, float fract, int direction)
      Original signature : PIX* pixUnsharpMaskingGrayFast(PIX*, l_int32, l_float32, l_int32)
    • pixUnsharpMaskingGray1D

      Pix pixUnsharpMaskingGray1D(Pix pixs, int halfwidth, float fract, int direction)
      Original signature : PIX* pixUnsharpMaskingGray1D(PIX*, l_int32, l_float32, l_int32)
    • pixUnsharpMaskingGray2D

      Pix pixUnsharpMaskingGray2D(Pix pixs, int halfwidth, float fract)
      Original signature : PIX* pixUnsharpMaskingGray2D(PIX*, l_int32, l_float32)
    • pixModifyHue

      Pix pixModifyHue(Pix pixd, Pix pixs, float fract)
      Original signature : PIX* pixModifyHue(PIX*, PIX*, l_float32)
    • pixModifySaturation

      Pix pixModifySaturation(Pix pixd, Pix pixs, float fract)
      Original signature : PIX* pixModifySaturation(PIX*, PIX*, l_float32)
    • pixMeasureSaturation

      int pixMeasureSaturation(Pix pixs, int factor, FloatBuffer psat)
      Original signature : l_int32 pixMeasureSaturation(PIX*, l_int32, l_float32*)
    • pixModifyBrightness

      Pix pixModifyBrightness(Pix pixd, Pix pixs, float fract)
      Original signature : PIX* pixModifyBrightness(PIX*, PIX*, l_float32)
    • pixColorShiftRGB

      Pix pixColorShiftRGB(Pix pixs, float rfract, float gfract, float bfract)
      Original signature : PIX* pixColorShiftRGB(PIX*, l_float32, l_float32, l_float32)
    • pixDarkenGray

      Pix pixDarkenGray(Pix pixd, Pix pixs, int thresh, int satlimit)
      Original signature : PIX* pixDarkenGray(PIX*, PIX*, l_int32, l_int32)
    • pixMultConstantColor

      Pix pixMultConstantColor(Pix pixs, float rfact, float gfact, float bfact)
      Original signature : PIX* pixMultConstantColor(PIX*, l_float32, l_float32, l_float32)
    • pixMultMatrixColor

      Pix pixMultMatrixColor(Pix pixs, L_Kernel kel)
      Original signature : PIX* pixMultMatrixColor(PIX*, L_KERNEL*)
    • pixHalfEdgeByBandpass

      Pix pixHalfEdgeByBandpass(Pix pixs, int sm1h, int sm1v, int sm2h, int sm2v)
      Original signature : PIX* pixHalfEdgeByBandpass(PIX*, l_int32, l_int32, l_int32, l_int32)
    • fhmtautogen

      int fhmtautogen(Sela sela, int fileindex, String filename)
      Original signature : l_ok fhmtautogen(SELA*, l_int32, const char*)
    • fhmtautogen1

      int fhmtautogen1(Sela sela, int fileindex, String filename)
      Original signature : l_ok fhmtautogen1(SELA*, l_int32, const char*)
    • fhmtautogen2

      int fhmtautogen2(Sela sela, int fileindex, String filename)
      Original signature : l_ok fhmtautogen2(SELA*, l_int32, const char*)
    • pixHMTDwa_1

      Pix pixHMTDwa_1(Pix pixd, Pix pixs, String selname)
      Original signature : PIX* pixHMTDwa_1(PIX*, PIX*, const char*)
    • pixFHMTGen_1

      Pix pixFHMTGen_1(Pix pixd, Pix pixs, String selname)
      Original signature : PIX* pixFHMTGen_1(PIX*, PIX*, const char*)
    • fhmtgen_low_1

      int fhmtgen_low_1(IntBuffer datad, int w, int h, int wpld, IntBuffer datas, int wpls, int index)
      Original signature : l_int32 fhmtgen_low_1(l_uint32*, l_int32, l_int32, l_int32, l_uint32*, l_int32, l_int32)
    • pixItalicWords

      int pixItalicWords(Pix pixs, Boxa boxaw, Pix pixw, com.sun.jna.ptr.PointerByReference pboxa, int debugflag)
      Original signature : l_ok pixItalicWords(PIX*, BOXA*, PIX*, BOXA**, l_int32)
    • pixOrientDetect

      int pixOrientDetect(Pix pixs, FloatBuffer pupconf, FloatBuffer pleftconf, int mincount, int debug)
      Original signature : l_ok pixOrientDetect(PIX*, l_float32*, l_float32*, l_int32, l_int32)
    • makeOrientDecision

      int makeOrientDecision(float upconf, float leftconf, float minupconf, float minratio, IntBuffer porient, int debug)
      Original signature : l_ok makeOrientDecision(l_float32, l_float32, l_float32, l_float32, l_int32*, l_int32)
    • pixUpDownDetect

      int pixUpDownDetect(Pix pixs, FloatBuffer pconf, int mincount, int debug)
      Original signature : l_ok pixUpDownDetect(PIX*, l_float32*, l_int32, l_int32)
    • pixUpDownDetectGeneral

      int pixUpDownDetectGeneral(Pix pixs, FloatBuffer pconf, int mincount, int npixels, int debug)
      Original signature : l_ok pixUpDownDetectGeneral(PIX*, l_float32*, l_int32, l_int32, l_int32)
    • pixOrientDetectDwa

      int pixOrientDetectDwa(Pix pixs, FloatBuffer pupconf, FloatBuffer pleftconf, int mincount, int debug)
      Original signature : l_ok pixOrientDetectDwa(PIX*, l_float32*, l_float32*, l_int32, l_int32)
    • pixUpDownDetectDwa

      int pixUpDownDetectDwa(Pix pixs, FloatBuffer pconf, int mincount, int debug)
      Original signature : l_ok pixUpDownDetectDwa(PIX*, l_float32*, l_int32, l_int32)
    • pixUpDownDetectGeneralDwa

      int pixUpDownDetectGeneralDwa(Pix pixs, FloatBuffer pconf, int mincount, int npixels, int debug)
      Original signature : l_ok pixUpDownDetectGeneralDwa(PIX*, l_float32*, l_int32, l_int32, l_int32)
    • pixMirrorDetect

      int pixMirrorDetect(Pix pixs, FloatBuffer pconf, int mincount, int debug)
      Original signature : l_ok pixMirrorDetect(PIX*, l_float32*, l_int32, l_int32)
    • fmorphautogen

      int fmorphautogen(Sela sela, int fileindex, String filename)
      Original signature : l_ok fmorphautogen(SELA*, l_int32, const char*)
    • fmorphautogen1

      int fmorphautogen1(Sela sela, int fileindex, String filename)
      Original signature : l_ok fmorphautogen1(SELA*, l_int32, const char*)
    • fmorphautogen2

      int fmorphautogen2(Sela sela, int fileindex, String filename)
      Original signature : l_ok fmorphautogen2(SELA*, l_int32, const char*)
    • pixMorphDwa_1

      Pix pixMorphDwa_1(Pix pixd, Pix pixs, int operation, ByteBuffer selname)
      Original signature : PIX* pixMorphDwa_1(PIX*, PIX*, l_int32, char*)
    • pixFMorphopGen_1

      Pix pixFMorphopGen_1(Pix pixd, Pix pixs, int operation, ByteBuffer selname)
      Original signature : PIX* pixFMorphopGen_1(PIX*, PIX*, l_int32, char*)
    • fpixReadMem

      FPix fpixReadMem(ByteBuffer data, NativeSize size)
      Original signature : FPIX* fpixReadMem(const l_uint8*, size_t)
    • fpixWriteMem

      int fpixWriteMem(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, FPix fpix)
      Original signature : l_ok fpixWriteMem(l_uint8**, size_t*, FPIX*)
    • dpixReadMem

      DPix dpixReadMem(ByteBuffer data, NativeSize size)
      Original signature : DPIX* dpixReadMem(const l_uint8*, size_t)
    • dpixWriteMem

      int dpixWriteMem(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, DPix dpix)
      Original signature : l_ok dpixWriteMem(l_uint8**, size_t*, DPIX*)
    • linearInterpolatePixelFloat

      int linearInterpolatePixelFloat(FloatBuffer datas, int w, int h, float x, float y, float inval, FloatBuffer pval)
      Original signature : l_ok linearInterpolatePixelFloat(l_float32*, l_int32, l_int32, l_float32, l_float32, l_float32, l_float32*)
    • fpixThresholdToPix

      Pix fpixThresholdToPix(FPix fpix, float thresh)
      Original signature : PIX* fpixThresholdToPix(FPIX*, l_float32)
    • pixComponentFunction

      FPix pixComponentFunction(Pix pix, float rnum, float gnum, float bnum, float rdenom, float gdenom, float bdenom)
      Original signature : FPIX* pixComponentFunction(PIX*, l_float32, l_float32, l_float32, l_float32, l_float32, l_float32)
    • pixReadMemGif

      Pix pixReadMemGif(ByteBuffer cdata, NativeSize size)
      Original signature : PIX* pixReadMemGif(const l_uint8*, size_t)
    • pixWriteMemGif

      int pixWriteMemGif(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, Pix pix)
      Original signature : l_ok pixWriteMemGif(l_uint8**, size_t*, PIX*)
    • generatePtaGrid

      Pta generatePtaGrid(int w, int h, int nx, int ny, int width)
      Original signature : PTA* generatePtaGrid(l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixRenderLine

      int pixRenderLine(Pix pix, int x1, int y1, int x2, int y2, int width, int op)
      Original signature : l_ok pixRenderLine(PIX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixRenderLineArb

      int pixRenderLineArb(Pix pix, int x1, int y1, int x2, int y2, int width, byte rval, byte gval, byte bval)
      Original signature : l_ok pixRenderLineArb(PIX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_uint8, l_uint8, l_uint8)
    • pixRenderLineBlend

      int pixRenderLineBlend(Pix pix, int x1, int y1, int x2, int y2, int width, byte rval, byte gval, byte bval, float fract)
      Original signature : l_ok pixRenderLineBlend(PIX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_uint8, l_uint8, l_uint8, l_float32)
    • pixRenderBox

      int pixRenderBox(Pix pix, Box box, int width, int op)
      Original signature : l_ok pixRenderBox(PIX*, BOX*, l_int32, l_int32)
    • pixRenderBoxArb

      int pixRenderBoxArb(Pix pix, Box box, int width, byte rval, byte gval, byte bval)
      Original signature : l_ok pixRenderBoxArb(PIX*, BOX*, l_int32, l_uint8, l_uint8, l_uint8)
    • pixRenderBoxBlend

      int pixRenderBoxBlend(Pix pix, Box box, int width, byte rval, byte gval, byte bval, float fract)
      Original signature : l_ok pixRenderBoxBlend(PIX*, BOX*, l_int32, l_uint8, l_uint8, l_uint8, l_float32)
    • pixRenderBoxa

      int pixRenderBoxa(Pix pix, Boxa boxa, int width, int op)
      Original signature : l_ok pixRenderBoxa(PIX*, BOXA*, l_int32, l_int32)
    • pixRenderBoxaArb

      int pixRenderBoxaArb(Pix pix, Boxa boxa, int width, byte rval, byte gval, byte bval)
      Original signature : l_ok pixRenderBoxaArb(PIX*, BOXA*, l_int32, l_uint8, l_uint8, l_uint8)
    • pixRenderBoxaBlend

      int pixRenderBoxaBlend(Pix pix, Boxa boxa, int width, byte rval, byte gval, byte bval, float fract, int removedups)
      Original signature : l_ok pixRenderBoxaBlend(PIX*, BOXA*, l_int32, l_uint8, l_uint8, l_uint8, l_float32, l_int32)
    • pixRenderHashBox

      int pixRenderHashBox(Pix pix, Box box, int spacing, int width, int orient, int outline, int op)
      Original signature : l_ok pixRenderHashBox(PIX*, BOX*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixRenderHashBoxArb

      int pixRenderHashBoxArb(Pix pix, Box box, int spacing, int width, int orient, int outline, int rval, int gval, int bval)
      Original signature : l_ok pixRenderHashBoxArb(PIX*, BOX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixRenderHashBoxBlend

      int pixRenderHashBoxBlend(Pix pix, Box box, int spacing, int width, int orient, int outline, int rval, int gval, int bval, float fract)
      Original signature : l_ok pixRenderHashBoxBlend(PIX*, BOX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, l_float32)
    • pixRenderHashMaskArb

      int pixRenderHashMaskArb(Pix pix, Pix pixm, int x, int y, int spacing, int width, int orient, int outline, int rval, int gval, int bval)
      Original signature : l_ok pixRenderHashMaskArb(PIX*, PIX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixRenderHashBoxa

      int pixRenderHashBoxa(Pix pix, Boxa boxa, int spacing, int width, int orient, int outline, int op)
      Original signature : l_ok pixRenderHashBoxa(PIX*, BOXA*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixRenderHashBoxaArb

      int pixRenderHashBoxaArb(Pix pix, Boxa boxa, int spacing, int width, int orient, int outline, int rval, int gval, int bval)
      Original signature : l_ok pixRenderHashBoxaArb(PIX*, BOXA*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixRenderHashBoxaBlend

      int pixRenderHashBoxaBlend(Pix pix, Boxa boxa, int spacing, int width, int orient, int outline, int rval, int gval, int bval, float fract)
      Original signature : l_ok pixRenderHashBoxaBlend(PIX*, BOXA*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, l_float32)
    • pixRenderPolyline

      int pixRenderPolyline(Pix pix, Pta ptas, int width, int op, int closeflag)
      Original signature : l_ok pixRenderPolyline(PIX*, PTA*, l_int32, l_int32, l_int32)
    • pixRenderPolylineArb

      int pixRenderPolylineArb(Pix pix, Pta ptas, int width, byte rval, byte gval, byte bval, int closeflag)
      Original signature : l_ok pixRenderPolylineArb(PIX*, PTA*, l_int32, l_uint8, l_uint8, l_uint8, l_int32)
    • pixRenderPolylineBlend

      int pixRenderPolylineBlend(Pix pix, Pta ptas, int width, byte rval, byte gval, byte bval, float fract, int closeflag, int removedups)
      Original signature : l_ok pixRenderPolylineBlend(PIX*, PTA*, l_int32, l_uint8, l_uint8, l_uint8, l_float32, l_int32, l_int32)
    • pixRenderGridArb

      int pixRenderGridArb(Pix pix, int nx, int ny, int width, byte rval, byte gval, byte bval)
      Original signature : l_ok pixRenderGridArb(PIX*, l_int32, l_int32, l_int32, l_uint8, l_uint8, l_uint8)
    • pixRenderRandomCmapPtaa

      Pix pixRenderRandomCmapPtaa(Pix pix, Ptaa ptaa, int polyflag, int width, int closeflag)
      Original signature : PIX* pixRenderRandomCmapPtaa(PIX*, PTAA*, l_int32, l_int32, l_int32)
    • pixRenderPolygon

      Pix pixRenderPolygon(Pta ptas, int width, IntBuffer pxmin, IntBuffer pymin)
      Original signature : PIX* pixRenderPolygon(PTA*, l_int32, l_int32*, l_int32*)
    • pixFillPolygon

      Pix pixFillPolygon(Pix pixs, Pta pta, int xmin, int ymin)
      Original signature : PIX* pixFillPolygon(PIX*, PTA*, l_int32, l_int32)
    • pixRenderContours

      Pix pixRenderContours(Pix pixs, int startval, int incr, int outdepth)
      Original signature : PIX* pixRenderContours(PIX*, l_int32, l_int32, l_int32)
    • fpixAutoRenderContours

      Pix fpixAutoRenderContours(FPix fpix, int ncontours)
      Original signature : PIX* fpixAutoRenderContours(FPIX*, l_int32)
    • fpixRenderContours

      Pix fpixRenderContours(FPix fpixs, float incr, float proxim)
      Original signature : PIX* fpixRenderContours(FPIX*, l_float32, l_float32)
    • pixGeneratePtaBoundary

      Pta pixGeneratePtaBoundary(Pix pixs, int width)
      Original signature : PTA* pixGeneratePtaBoundary(PIX*, l_int32)
    • pixErodeGray

      Pix pixErodeGray(Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixErodeGray(PIX*, l_int32, l_int32)
    • pixDilateGray

      Pix pixDilateGray(Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixDilateGray(PIX*, l_int32, l_int32)
    • pixOpenGray

      Pix pixOpenGray(Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixOpenGray(PIX*, l_int32, l_int32)
    • pixCloseGray

      Pix pixCloseGray(Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixCloseGray(PIX*, l_int32, l_int32)
    • pixErodeGray3

      Pix pixErodeGray3(Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixErodeGray3(PIX*, l_int32, l_int32)
    • pixDilateGray3

      Pix pixDilateGray3(Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixDilateGray3(PIX*, l_int32, l_int32)
    • pixOpenGray3

      Pix pixOpenGray3(Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixOpenGray3(PIX*, l_int32, l_int32)
    • pixCloseGray3

      Pix pixCloseGray3(Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixCloseGray3(PIX*, l_int32, l_int32)
    • pixDitherToBinary

      Pix pixDitherToBinary(Pix pixs)
      Original signature : PIX* pixDitherToBinary(PIX*)
    • pixDitherToBinarySpec

      Pix pixDitherToBinarySpec(Pix pixs, int lowerclip, int upperclip)
      Original signature : PIX* pixDitherToBinarySpec(PIX*, l_int32, l_int32)
    • pixThresholdToBinary

      Pix pixThresholdToBinary(Pix pixs, int thresh)
      Original signature : PIX* pixThresholdToBinary(PIX*, l_int32)
    • pixVarThresholdToBinary

      Pix pixVarThresholdToBinary(Pix pixs, Pix pixg)
      Original signature : PIX* pixVarThresholdToBinary(PIX*, PIX*)
    • pixAdaptThresholdToBinary

      Pix pixAdaptThresholdToBinary(Pix pixs, Pix pixm, float gamma)
      Original signature : PIX* pixAdaptThresholdToBinary(PIX*, PIX*, l_float32)
    • pixAdaptThresholdToBinaryGen

      Pix pixAdaptThresholdToBinaryGen(Pix pixs, Pix pixm, float gamma, int blackval, int whiteval, int thresh)
      Original signature : PIX* pixAdaptThresholdToBinaryGen(PIX*, PIX*, l_float32, l_int32, l_int32, l_int32)
    • pixGenerateMaskByValue

      Pix pixGenerateMaskByValue(Pix pixs, int val, int usecmap)
      Original signature : PIX* pixGenerateMaskByValue(PIX*, l_int32, l_int32)
    • pixGenerateMaskByBand

      Pix pixGenerateMaskByBand(Pix pixs, int lower, int upper, int inband, int usecmap)
      Original signature : PIX* pixGenerateMaskByBand(PIX*, l_int32, l_int32, l_int32, l_int32)
    • pixDitherTo2bpp

      Pix pixDitherTo2bpp(Pix pixs, int cmapflag)
      Original signature : PIX* pixDitherTo2bpp(PIX*, l_int32)
    • pixDitherTo2bppSpec

      Pix pixDitherTo2bppSpec(Pix pixs, int lowerclip, int upperclip, int cmapflag)
      Original signature : PIX* pixDitherTo2bppSpec(PIX*, l_int32, l_int32, l_int32)
    • pixThresholdTo2bpp

      Pix pixThresholdTo2bpp(Pix pixs, int nlevels, int cmapflag)
      Original signature : PIX* pixThresholdTo2bpp(PIX*, l_int32, l_int32)
    • pixThresholdTo4bpp

      Pix pixThresholdTo4bpp(Pix pixs, int nlevels, int cmapflag)
      Original signature : PIX* pixThresholdTo4bpp(PIX*, l_int32, l_int32)
    • pixThresholdOn8bpp

      Pix pixThresholdOn8bpp(Pix pixs, int nlevels, int cmapflag)
      Original signature : PIX* pixThresholdOn8bpp(PIX*, l_int32, l_int32)
    • pixThresholdGrayArb

      Pix pixThresholdGrayArb(Pix pixs, String edgevals, int outdepth, int use_average, int setblack, int setwhite)
      Original signature : PIX* pixThresholdGrayArb(PIX*, const char*, l_int32, l_int32, l_int32, l_int32)
    • thresholdToBinaryLineLow

      void thresholdToBinaryLineLow(IntBuffer lined, int w, IntBuffer lines, int d, int thresh)
      Original signature : void thresholdToBinaryLineLow(l_uint32*, l_int32, l_uint32*, l_int32, l_int32)
    • lheapCreate

      L_Heap lheapCreate(int n, int direction)
      Original signature : L_HEAP* lheapCreate(l_int32, l_int32)
    • lheapDestroy

      void lheapDestroy(com.sun.jna.ptr.PointerByReference plh, int freeflag)
      Original signature : void lheapDestroy(L_HEAP**, l_int32)
    • lheapAdd

      int lheapAdd(L_Heap lh, com.sun.jna.Pointer item)
      Original signature : l_ok lheapAdd(L_HEAP*, void*)
    • lheapRemove

      com.sun.jna.Pointer lheapRemove(L_Heap lh)
      Original signature : void* lheapRemove(L_HEAP*)
    • lheapGetCount

      int lheapGetCount(L_Heap lh)
      Original signature : l_int32 lheapGetCount(L_HEAP*)
    • lheapGetElement

      com.sun.jna.Pointer lheapGetElement(L_Heap lh, int index)
      Original signature : void* lheapGetElement(L_HEAP*, l_int32)
    • lheapSort

      int lheapSort(L_Heap lh)
      Original signature : l_ok lheapSort(L_HEAP*)
    • lheapSortStrictOrder

      int lheapSortStrictOrder(L_Heap lh)
      Original signature : l_ok lheapSortStrictOrder(L_HEAP*)
    • pixWordMaskByDilation

      int pixWordMaskByDilation(Pix pixs, com.sun.jna.ptr.PointerByReference ppixm, IntBuffer psize, Pixa pixadb)
      Original signature : l_ok pixWordMaskByDilation(PIX*, PIX**, l_int32*, PIXA*)
    • pixWordMaskByDilation

      int pixWordMaskByDilation(Pix pixs, com.sun.jna.ptr.PointerByReference ppixm, com.sun.jna.ptr.IntByReference psize, Pixa pixadb)
      Original signature : l_ok pixWordMaskByDilation(PIX*, PIX**, l_int32*, PIXA*)
    • pixWordBoxesByDilation

      int pixWordBoxesByDilation(Pix pixs, int minwidth, int minheight, int maxwidth, int maxheight, com.sun.jna.ptr.PointerByReference pboxa, IntBuffer psize, Pixa pixadb)
      Original signature : l_ok pixWordBoxesByDilation(PIX*, l_int32, l_int32, l_int32, l_int32, BOXA**, l_int32*, PIXA*)
    • pixWordBoxesByDilation

      int pixWordBoxesByDilation(Pix pixs, int minwidth, int minheight, int maxwidth, int maxheight, com.sun.jna.ptr.PointerByReference pboxa, com.sun.jna.ptr.IntByReference psize, Pixa pixadb)
      Original signature : l_ok pixWordBoxesByDilation(PIX*, l_int32, l_int32, l_int32, l_int32, BOXA**, l_int32*, PIXA*)
    • jbAccumulateComposites

      Pixa jbAccumulateComposites(Pixaa pixaa, com.sun.jna.ptr.PointerByReference pna, com.sun.jna.ptr.PointerByReference pptat)
      Original signature : PIXA* jbAccumulateComposites(PIXAA*, NUMA**, PTA**)
    • jbTemplatesFromComposites

      Pixa jbTemplatesFromComposites(Pixa pixac, Numa na)
      Original signature : PIXA* jbTemplatesFromComposites(PIXA*, NUMA*)
    • jbClasserCreate

      JbClasser jbClasserCreate(int method, int components)
      Original signature : JBCLASSER* jbClasserCreate(l_int32, l_int32)
    • jbClasserDestroy

      void jbClasserDestroy(com.sun.jna.ptr.PointerByReference pclasser)
      Original signature : void jbClasserDestroy(JBCLASSER**)
    • jbDataSave

      JbData jbDataSave(JbClasser classer)
      Original signature : JBDATA* jbDataSave(JBCLASSER*)
    • jbDataDestroy

      void jbDataDestroy(com.sun.jna.ptr.PointerByReference pdata)
      Original signature : void jbDataDestroy(JBDATA**)
    • jbDataWrite

      int jbDataWrite(String rootout, JbData jbdata)
      Original signature : l_ok jbDataWrite(const char*, JBDATA*)
    • jbDataRead

      JbData jbDataRead(String rootname)
      Original signature : JBDATA* jbDataRead(const char*)
    • jbDataRender

      Pixa jbDataRender(JbData data, int debugflag)
      Original signature : PIXA* jbDataRender(JBDATA*, l_int32)
    • jbGetULCorners

      int jbGetULCorners(JbClasser classer, Pix pixs, Boxa boxa)
      Original signature : l_ok jbGetULCorners(JBCLASSER*, PIX*, BOXA*)
    • jbGetLLCorners

      int jbGetLLCorners(JbClasser classer)
      Original signature : l_ok jbGetLLCorners(JBCLASSER*)
    • readHeaderJp2k

      int readHeaderJp2k(String filename, IntBuffer pw, IntBuffer ph, IntBuffer pbps, IntBuffer pspp, IntBuffer pcodec)
      Original signature : l_ok readHeaderJp2k(const char*, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*)
    • freadHeaderJp2k

      int freadHeaderJp2k(ILeptonica.FILE fp, IntBuffer pw, IntBuffer ph, IntBuffer pbps, IntBuffer pspp, IntBuffer pcodec)
      Original signature : l_ok freadHeaderJp2k(FILE*, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*)
    • readHeaderMemJp2k

      int readHeaderMemJp2k(ByteBuffer data, NativeSize size, IntBuffer pw, IntBuffer ph, IntBuffer pbps, IntBuffer pspp, IntBuffer pcodec)
      Original signature : l_ok readHeaderMemJp2k(const l_uint8*, size_t, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*)
    • pixReadJp2k

      Pix pixReadJp2k(String filename, int reduction, Box box, int hint, int debug)
      Original signature : PIX* pixReadJp2k(const char*, l_uint32, BOX*, l_int32, l_int32)
    • pixWriteJp2k

      int pixWriteJp2k(String filename, Pix pix, int quality, int nlevels, int hint, int debug)
      Original signature : l_ok pixWriteJp2k(const char*, PIX*, l_int32, l_int32, l_int32, l_int32)
    • pixWriteStreamJp2k

      int pixWriteStreamJp2k(ILeptonica.FILE fp, Pix pix, int quality, int nlevels, int codec, int hint, int debug)
      Original signature : l_ok pixWriteStreamJp2k(FILE*, PIX*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixReadMemJp2k

      Pix pixReadMemJp2k(ByteBuffer data, NativeSize size, int reduction, Box box, int hint, int debug)
      Original signature : PIX* pixReadMemJp2k(const l_uint8*, size_t, l_uint32, BOX*, l_int32, l_int32)
    • pixWriteMemJp2k

      int pixWriteMemJp2k(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, Pix pix, int quality, int nlevels, int hint, int debug)
      Original signature : l_ok pixWriteMemJp2k(l_uint8**, size_t*, PIX*, l_int32, l_int32, l_int32, l_int32)
    • pixReadJpeg

      Pix pixReadJpeg(String filename, int cmapflag, int reduction, IntBuffer pnwarn, int hint)
      Original signature : PIX* pixReadJpeg(const char*, l_int32, l_int32, l_int32*, l_int32)
    • readHeaderJpeg

      int readHeaderJpeg(String filename, IntBuffer pw, IntBuffer ph, IntBuffer pspp, IntBuffer pycck, IntBuffer pcmyk)
      Original signature : l_ok readHeaderJpeg(const char*, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*)
    • pixWriteJpeg

      int pixWriteJpeg(String filename, Pix pix, int quality, int progressive)
      Original signature : l_ok pixWriteJpeg(const char*, PIX*, l_int32, l_int32)
    • pixReadMemJpeg

      Pix pixReadMemJpeg(ByteBuffer data, NativeSize size, int cmflag, int reduction, IntBuffer pnwarn, int hint)
      Original signature : PIX* pixReadMemJpeg(const l_uint8*, size_t, l_int32, l_int32, l_int32*, l_int32)
    • readHeaderMemJpeg

      int readHeaderMemJpeg(ByteBuffer data, NativeSize size, IntBuffer pw, IntBuffer ph, IntBuffer pspp, IntBuffer pycck, IntBuffer pcmyk)
      Original signature : l_ok readHeaderMemJpeg(const l_uint8*, size_t, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*)
    • pixWriteMemJpeg

      int pixWriteMemJpeg(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, Pix pix, int quality, int progressive)
      Original signature : l_ok pixWriteMemJpeg(l_uint8**, size_t*, PIX*, l_int32, l_int32)
    • pixSetChromaSampling

      int pixSetChromaSampling(Pix pix, int sampling)
      Original signature : l_ok pixSetChromaSampling(PIX*, l_int32)
    • kernelCreate

      L_Kernel kernelCreate(int height, int width)
      Original signature : L_KERNEL* kernelCreate(l_int32, l_int32)
    • kernelDestroy

      void kernelDestroy(com.sun.jna.ptr.PointerByReference pkel)
      Original signature : void kernelDestroy(L_KERNEL**)
    • kernelCopy

      L_Kernel kernelCopy(L_Kernel kels)
      Original signature : L_KERNEL* kernelCopy(L_KERNEL*)
    • kernelGetElement

      int kernelGetElement(L_Kernel kel, int row, int col, FloatBuffer pval)
      Original signature : l_ok kernelGetElement(L_KERNEL*, l_int32, l_int32, l_float32*)
    • kernelSetElement

      int kernelSetElement(L_Kernel kel, int row, int col, float val)
      Original signature : l_ok kernelSetElement(L_KERNEL*, l_int32, l_int32, l_float32)
    • kernelGetParameters

      int kernelGetParameters(L_Kernel kel, IntBuffer psy, IntBuffer psx, IntBuffer pcy, IntBuffer pcx)
      Original signature : l_ok kernelGetParameters(L_KERNEL*, l_int32*, l_int32*, l_int32*, l_int32*)
    • kernelSetOrigin

      int kernelSetOrigin(L_Kernel kel, int cy, int cx)
      Original signature : l_ok kernelSetOrigin(L_KERNEL*, l_int32, l_int32)
    • kernelGetSum

      int kernelGetSum(L_Kernel kel, FloatBuffer psum)
      Original signature : l_ok kernelGetSum(L_KERNEL*, l_float32*)
    • kernelGetMinMax

      int kernelGetMinMax(L_Kernel kel, FloatBuffer pmin, FloatBuffer pmax)
      Original signature : l_ok kernelGetMinMax(L_KERNEL*, l_float32*, l_float32*)
    • kernelNormalize

      L_Kernel kernelNormalize(L_Kernel kels, float normsum)
      Original signature : L_KERNEL* kernelNormalize(L_KERNEL*, l_float32)
    • kernelInvert

      L_Kernel kernelInvert(L_Kernel kels)
      Original signature : L_KERNEL* kernelInvert(L_KERNEL*)
    • create2dFloatArray

      com.sun.jna.ptr.PointerByReference create2dFloatArray(int sy, int sx)
      Original signature : l_float32** create2dFloatArray(l_int32, l_int32)
    • kernelRead

      L_Kernel kernelRead(String fname)
      Original signature : L_KERNEL* kernelRead(const char*)
    • kernelWrite

      int kernelWrite(String fname, L_Kernel kel)
      Original signature : l_ok kernelWrite(const char*, L_KERNEL*)
    • kernelCreateFromString

      L_Kernel kernelCreateFromString(int h, int w, int cy, int cx, String kdata)
      Original signature : L_KERNEL* kernelCreateFromString(l_int32, l_int32, l_int32, l_int32, const char*)
    • kernelCreateFromFile

      L_Kernel kernelCreateFromFile(String filename)
      Original signature : L_KERNEL* kernelCreateFromFile(const char*)
    • kernelCreateFromPix

      L_Kernel kernelCreateFromPix(Pix pix, int cy, int cx)
      Original signature : L_KERNEL* kernelCreateFromPix(PIX*, l_int32, l_int32)
    • kernelDisplayInPix

      Pix kernelDisplayInPix(L_Kernel kel, int size, int gthick)
      Original signature : PIX* kernelDisplayInPix(L_KERNEL*, l_int32, l_int32)
    • parseStringForNumbers

      Numa parseStringForNumbers(String str, String seps)
      Original signature : NUMA* parseStringForNumbers(const char*, const char*)
    • getImagelibVersions

      com.sun.jna.Pointer getImagelibVersions()
      Original signature : char* getImagelibVersions()
    • listDestroy

      void listDestroy(com.sun.jna.ptr.PointerByReference phead)
      Original signature : void listDestroy(DLLIST**)
    • listAddToHead

      int listAddToHead(com.sun.jna.ptr.PointerByReference phead, com.sun.jna.Pointer data)
      Original signature : l_ok listAddToHead(DLLIST**, void*)
    • listAddToTail

      int listAddToTail(com.sun.jna.ptr.PointerByReference phead, com.sun.jna.ptr.PointerByReference ptail, com.sun.jna.Pointer data)
      Original signature : l_ok listAddToTail(DLLIST**, DLLIST**, void*)
    • listInsertBefore

      int listInsertBefore(com.sun.jna.ptr.PointerByReference phead, DoubleLinkedList elem, com.sun.jna.Pointer data)
      Original signature : l_ok listInsertBefore(DLLIST**, DLLIST*, void*)
    • listInsertAfter

      int listInsertAfter(com.sun.jna.ptr.PointerByReference phead, DoubleLinkedList elem, com.sun.jna.Pointer data)
      Original signature : l_ok listInsertAfter(DLLIST**, DLLIST*, void*)
    • listRemoveElement

      com.sun.jna.Pointer listRemoveElement(com.sun.jna.ptr.PointerByReference phead, DoubleLinkedList elem)
      Original signature : void* listRemoveElement(DLLIST**, DLLIST*)
    • listRemoveFromHead

      com.sun.jna.Pointer listRemoveFromHead(com.sun.jna.ptr.PointerByReference phead)
      Original signature : void* listRemoveFromHead(DLLIST**)
    • listRemoveFromTail

      com.sun.jna.Pointer listRemoveFromTail(com.sun.jna.ptr.PointerByReference phead, com.sun.jna.ptr.PointerByReference ptail)
      Original signature : void* listRemoveFromTail(DLLIST**, DLLIST**)
    • listFindElement

      DoubleLinkedList listFindElement(DoubleLinkedList head, com.sun.jna.Pointer data)
      Original signature : DLLIST* listFindElement(DLLIST*, void*)
    • listFindTail

      DoubleLinkedList listFindTail(DoubleLinkedList head)
      Original signature : DLLIST* listFindTail(DLLIST*)
    • listGetCount

      int listGetCount(DoubleLinkedList head)
      Original signature : l_int32 listGetCount(DLLIST*)
    • listReverse

      int listReverse(com.sun.jna.ptr.PointerByReference phead)
      Original signature : l_ok listReverse(DLLIST**)
    • listJoin

      int listJoin(com.sun.jna.ptr.PointerByReference phead1, com.sun.jna.ptr.PointerByReference phead2)
      Original signature : l_ok listJoin(DLLIST**, DLLIST**)
    • l_amapCreate

      L_Rbtree l_amapCreate(int keytype)
      Original signature : L_AMAP* l_amapCreate(l_int32)
    • l_amapFind

      Rb_Type l_amapFind(L_Rbtree m, Rb_Type.ByValue key)
      Original signature : RB_TYPE* l_amapFind(L_AMAP*, RB_TYPE)
    • l_amapInsert

      void l_amapInsert(L_Rbtree m, Rb_Type.ByValue key, Rb_Type.ByValue value)
      Original signature : void l_amapInsert(L_AMAP*, RB_TYPE, RB_TYPE)
    • l_amapDelete

      void l_amapDelete(L_Rbtree m, Rb_Type.ByValue key)
      Original signature : void l_amapDelete(L_AMAP*, RB_TYPE)
    • l_amapDestroy

      void l_amapDestroy(com.sun.jna.ptr.PointerByReference pm)
      Original signature : void l_amapDestroy(L_AMAP**)
    • l_amapGetFirst

      L_Rbtree_Node l_amapGetFirst(L_Rbtree m)
      Original signature : L_AMAP_NODE* l_amapGetFirst(L_AMAP*)
    • l_amapGetNext

      L_Rbtree_Node l_amapGetNext(L_Rbtree_Node n)
      Original signature : L_AMAP_NODE* l_amapGetNext(L_AMAP_NODE*)
    • l_amapGetLast

      L_Rbtree_Node l_amapGetLast(L_Rbtree m)
      Original signature : L_AMAP_NODE* l_amapGetLast(L_AMAP*)
    • l_amapGetPrev

      L_Rbtree_Node l_amapGetPrev(L_Rbtree_Node n)
      Original signature : L_AMAP_NODE* l_amapGetPrev(L_AMAP_NODE*)
    • l_amapSize

      int l_amapSize(L_Rbtree m)
      Original signature : l_int32 l_amapSize(L_AMAP*)
    • l_asetCreate

      L_Rbtree l_asetCreate(int keytype)
      Original signature : L_ASET* l_asetCreate(l_int32)
    • l_asetFind

      Rb_Type l_asetFind(L_Rbtree s, Rb_Type.ByValue key)
      Original signature : RB_TYPE* l_asetFind(L_ASET*, RB_TYPE)
    • l_asetInsert

      void l_asetInsert(L_Rbtree s, Rb_Type.ByValue key)
      Original signature : void l_asetInsert(L_ASET*, RB_TYPE)
    • l_asetDelete

      void l_asetDelete(L_Rbtree s, Rb_Type.ByValue key)
      Original signature : void l_asetDelete(L_ASET*, RB_TYPE)
    • l_asetDestroy

      void l_asetDestroy(com.sun.jna.ptr.PointerByReference ps)
      Original signature : void l_asetDestroy(L_ASET**)
    • l_asetGetFirst

      L_Rbtree_Node l_asetGetFirst(L_Rbtree s)
      Original signature : L_ASET_NODE* l_asetGetFirst(L_ASET*)
    • l_asetGetNext

      L_Rbtree_Node l_asetGetNext(L_Rbtree_Node n)
      Original signature : L_ASET_NODE* l_asetGetNext(L_ASET_NODE*)
    • l_asetGetLast

      L_Rbtree_Node l_asetGetLast(L_Rbtree s)
      Original signature : L_ASET_NODE* l_asetGetLast(L_ASET*)
    • l_asetGetPrev

      L_Rbtree_Node l_asetGetPrev(L_Rbtree_Node n)
      Original signature : L_ASET_NODE* l_asetGetPrev(L_ASET_NODE*)
    • l_asetSize

      int l_asetSize(L_Rbtree s)
      Original signature : l_int32 l_asetSize(L_ASET*)
    • generateBinaryMaze

      Pix generateBinaryMaze(int w, int h, int xi, int yi, float wallps, float ranis)
      Original signature : PIX* generateBinaryMaze(l_int32, l_int32, l_int32, l_int32, l_float32, l_float32)
    • pixSearchBinaryMaze

      Pta pixSearchBinaryMaze(Pix pixs, int xi, int yi, int xf, int yf, com.sun.jna.ptr.PointerByReference ppixd)
      Original signature : PTA* pixSearchBinaryMaze(PIX*, l_int32, l_int32, l_int32, l_int32, PIX**)
    • pixSearchGrayMaze

      Pta pixSearchGrayMaze(Pix pixs, int xi, int yi, int xf, int yf, com.sun.jna.ptr.PointerByReference ppixd)
      Original signature : PTA* pixSearchGrayMaze(PIX*, l_int32, l_int32, l_int32, l_int32, PIX**)
    • pixDilate

      Pix pixDilate(Pix pixd, Pix pixs, com.sun.jna.Pointer sel)
      Original signature : PIX* pixDilate(PIX*, PIX*, SEL*)
    • pixErode

      Pix pixErode(Pix pixd, Pix pixs, com.sun.jna.Pointer sel)
      Original signature : PIX* pixErode(PIX*, PIX*, SEL*)
    • pixHMT

      Pix pixHMT(Pix pixd, Pix pixs, com.sun.jna.Pointer sel)
      Original signature : PIX* pixHMT(PIX*, PIX*, SEL*)
    • pixOpen

      Pix pixOpen(Pix pixd, Pix pixs, com.sun.jna.Pointer sel)
      Original signature : PIX* pixOpen(PIX*, PIX*, SEL*)
    • pixClose

      Pix pixClose(Pix pixd, Pix pixs, com.sun.jna.Pointer sel)
      Original signature : PIX* pixClose(PIX*, PIX*, SEL*)
    • pixCloseSafe

      Pix pixCloseSafe(Pix pixd, Pix pixs, com.sun.jna.Pointer sel)
      Original signature : PIX* pixCloseSafe(PIX*, PIX*, SEL*)
    • pixOpenGeneralized

      Pix pixOpenGeneralized(Pix pixd, Pix pixs, com.sun.jna.Pointer sel)
      Original signature : PIX* pixOpenGeneralized(PIX*, PIX*, SEL*)
    • pixCloseGeneralized

      Pix pixCloseGeneralized(Pix pixd, Pix pixs, com.sun.jna.Pointer sel)
      Original signature : PIX* pixCloseGeneralized(PIX*, PIX*, SEL*)
    • pixDilateBrick

      Pix pixDilateBrick(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixDilateBrick(PIX*, PIX*, l_int32, l_int32)
    • pixErodeBrick

      Pix pixErodeBrick(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixErodeBrick(PIX*, PIX*, l_int32, l_int32)
    • pixOpenBrick

      Pix pixOpenBrick(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixOpenBrick(PIX*, PIX*, l_int32, l_int32)
    • pixCloseBrick

      Pix pixCloseBrick(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixCloseBrick(PIX*, PIX*, l_int32, l_int32)
    • pixCloseSafeBrick

      Pix pixCloseSafeBrick(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixCloseSafeBrick(PIX*, PIX*, l_int32, l_int32)
    • selectComposableSels

      int selectComposableSels(int size, int direction, com.sun.jna.ptr.PointerByReference psel1, com.sun.jna.ptr.PointerByReference psel2)
      Original signature : l_int32 selectComposableSels(l_int32, l_int32, SEL**, SEL**)
    • selectComposableSizes

      int selectComposableSizes(int size, IntBuffer pfactor1, IntBuffer pfactor2)
      Original signature : l_ok selectComposableSizes(l_int32, l_int32*, l_int32*)
    • pixDilateCompBrick

      Pix pixDilateCompBrick(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixDilateCompBrick(PIX*, PIX*, l_int32, l_int32)
    • pixErodeCompBrick

      Pix pixErodeCompBrick(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixErodeCompBrick(PIX*, PIX*, l_int32, l_int32)
    • pixOpenCompBrick

      Pix pixOpenCompBrick(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixOpenCompBrick(PIX*, PIX*, l_int32, l_int32)
    • pixCloseCompBrick

      Pix pixCloseCompBrick(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixCloseCompBrick(PIX*, PIX*, l_int32, l_int32)
    • pixCloseSafeCompBrick

      Pix pixCloseSafeCompBrick(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixCloseSafeCompBrick(PIX*, PIX*, l_int32, l_int32)
    • resetMorphBoundaryCondition

      void resetMorphBoundaryCondition(int bc)
      Original signature : void resetMorphBoundaryCondition(l_int32)
    • getMorphBorderPixelColor

      int getMorphBorderPixelColor(int type, int depth)
      Original signature : l_uint32 getMorphBorderPixelColor(l_int32, l_int32)
    • pixExtractBoundary

      Pix pixExtractBoundary(Pix pixs, int type)
      Original signature : PIX* pixExtractBoundary(PIX*, l_int32)
    • pixMorphSequenceMasked

      Pix pixMorphSequenceMasked(Pix pixs, Pix pixm, String sequence, int dispsep)
      Original signature : PIX* pixMorphSequenceMasked(PIX*, PIX*, const char*, l_int32)
    • pixMorphSequenceByComponent

      Pix pixMorphSequenceByComponent(Pix pixs, String sequence, int connectivity, int minw, int minh, com.sun.jna.ptr.PointerByReference pboxa)
      Original signature : PIX* pixMorphSequenceByComponent(PIX*, const char*, l_int32, l_int32, l_int32, BOXA**)
    • pixMorphSequenceByComponent

      Pix pixMorphSequenceByComponent(Pix pixs, com.sun.jna.Pointer sequence, int connectivity, int minw, int minh, com.sun.jna.ptr.PointerByReference pboxa)
      Original signature : PIX* pixMorphSequenceByComponent(PIX*, const char*, l_int32, l_int32, l_int32, BOXA**)
    • pixaMorphSequenceByComponent

      Pixa pixaMorphSequenceByComponent(Pixa pixas, String sequence, int minw, int minh)
      Original signature : PIXA* pixaMorphSequenceByComponent(PIXA*, const char*, l_int32, l_int32)
    • pixMorphSequenceByRegion

      Pix pixMorphSequenceByRegion(Pix pixs, Pix pixm, String sequence, int connectivity, int minw, int minh, com.sun.jna.ptr.PointerByReference pboxa)
      Original signature : PIX* pixMorphSequenceByRegion(PIX*, PIX*, const char*, l_int32, l_int32, l_int32, BOXA**)
    • pixMorphSequenceByRegion

      Pix pixMorphSequenceByRegion(Pix pixs, Pix pixm, com.sun.jna.Pointer sequence, int connectivity, int minw, int minh, com.sun.jna.ptr.PointerByReference pboxa)
      Original signature : PIX* pixMorphSequenceByRegion(PIX*, PIX*, const char*, l_int32, l_int32, l_int32, BOXA**)
    • pixaMorphSequenceByRegion

      Pixa pixaMorphSequenceByRegion(Pix pixs, Pixa pixam, String sequence, int minw, int minh)
      Original signature : PIXA* pixaMorphSequenceByRegion(PIX*, PIXA*, const char*, l_int32, l_int32)
    • pixUnionOfMorphOps

      Pix pixUnionOfMorphOps(Pix pixs, Sela sela, int type)
      Original signature : PIX* pixUnionOfMorphOps(PIX*, SELA*, l_int32)
    • pixIntersectionOfMorphOps

      Pix pixIntersectionOfMorphOps(Pix pixs, Sela sela, int type)
      Original signature : PIX* pixIntersectionOfMorphOps(PIX*, SELA*, l_int32)
    • pixSelectiveConnCompFill

      Pix pixSelectiveConnCompFill(Pix pixs, int connectivity, int minw, int minh)
      Original signature : PIX* pixSelectiveConnCompFill(PIX*, l_int32, l_int32, l_int32)
    • pixRemoveMatchedPattern

      int pixRemoveMatchedPattern(Pix pixs, Pix pixp, Pix pixe, int x0, int y0, int dsize)
      Original signature : l_ok pixRemoveMatchedPattern(PIX*, PIX*, PIX*, l_int32, l_int32, l_int32)
    • pixDisplayMatchedPattern

      Pix pixDisplayMatchedPattern(Pix pixs, Pix pixp, Pix pixe, int x0, int y0, int color, float scale, int nlevels)
      Original signature : PIX* pixDisplayMatchedPattern(PIX*, PIX*, PIX*, l_int32, l_int32, l_uint32, l_float32, l_int32)
    • pixaExtendByMorph

      Pixa pixaExtendByMorph(Pixa pixas, int type, int niters, com.sun.jna.Pointer sel, int include)
      Original signature : PIXA* pixaExtendByMorph(PIXA*, l_int32, l_int32, SEL*, l_int32)
    • pixaExtendByScaling

      Pixa pixaExtendByScaling(Pixa pixas, Numa nasc, int type, int include)
      Original signature : PIXA* pixaExtendByScaling(PIXA*, NUMA*, l_int32, l_int32)
    • pixSeedfillMorph

      Pix pixSeedfillMorph(Pix pixs, Pix pixm, int maxiters, int connectivity)
      Original signature : PIX* pixSeedfillMorph(PIX*, PIX*, l_int32, l_int32)
    • pixRunHistogramMorph

      Numa pixRunHistogramMorph(Pix pixs, int runtype, int direction, int maxsize)
      Original signature : NUMA* pixRunHistogramMorph(PIX*, l_int32, l_int32, l_int32)
    • pixTophat

      Pix pixTophat(Pix pixs, int hsize, int vsize, int type)
      Original signature : PIX* pixTophat(PIX*, l_int32, l_int32, l_int32)
    • pixHDome

      Pix pixHDome(Pix pixs, int height, int connectivity)
      Original signature : PIX* pixHDome(PIX*, l_int32, l_int32)
    • pixFastTophat

      Pix pixFastTophat(Pix pixs, int xsize, int ysize, int type)
      Original signature : PIX* pixFastTophat(PIX*, l_int32, l_int32, l_int32)
    • pixMorphGradient

      Pix pixMorphGradient(Pix pixs, int hsize, int vsize, int smoothing)
      Original signature : PIX* pixMorphGradient(PIX*, l_int32, l_int32, l_int32)
    • pixaCentroids

      Pta pixaCentroids(Pixa pixa)
      Original signature : PTA* pixaCentroids(PIXA*)
    • pixCentroid

      int pixCentroid(Pix pix, IntBuffer centtab, IntBuffer sumtab, FloatBuffer pxave, FloatBuffer pyave)
      Original signature : l_ok pixCentroid(PIX*, l_int32*, l_int32*, l_float32*, l_float32*)
    • pixDilateBrickDwa

      Pix pixDilateBrickDwa(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixDilateBrickDwa(PIX*, PIX*, l_int32, l_int32)
    • pixErodeBrickDwa

      Pix pixErodeBrickDwa(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixErodeBrickDwa(PIX*, PIX*, l_int32, l_int32)
    • pixOpenBrickDwa

      Pix pixOpenBrickDwa(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixOpenBrickDwa(PIX*, PIX*, l_int32, l_int32)
    • pixCloseBrickDwa

      Pix pixCloseBrickDwa(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixCloseBrickDwa(PIX*, PIX*, l_int32, l_int32)
    • pixDilateCompBrickDwa

      Pix pixDilateCompBrickDwa(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixDilateCompBrickDwa(PIX*, PIX*, l_int32, l_int32)
    • pixErodeCompBrickDwa

      Pix pixErodeCompBrickDwa(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixErodeCompBrickDwa(PIX*, PIX*, l_int32, l_int32)
    • pixOpenCompBrickDwa

      Pix pixOpenCompBrickDwa(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixOpenCompBrickDwa(PIX*, PIX*, l_int32, l_int32)
    • pixCloseCompBrickDwa

      Pix pixCloseCompBrickDwa(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixCloseCompBrickDwa(PIX*, PIX*, l_int32, l_int32)
    • pixDilateCompBrickExtendDwa

      Pix pixDilateCompBrickExtendDwa(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixDilateCompBrickExtendDwa(PIX*, PIX*, l_int32, l_int32)
    • pixErodeCompBrickExtendDwa

      Pix pixErodeCompBrickExtendDwa(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixErodeCompBrickExtendDwa(PIX*, PIX*, l_int32, l_int32)
    • pixOpenCompBrickExtendDwa

      Pix pixOpenCompBrickExtendDwa(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixOpenCompBrickExtendDwa(PIX*, PIX*, l_int32, l_int32)
    • pixCloseCompBrickExtendDwa

      Pix pixCloseCompBrickExtendDwa(Pix pixd, Pix pixs, int hsize, int vsize)
      Original signature : PIX* pixCloseCompBrickExtendDwa(PIX*, PIX*, l_int32, l_int32)
    • getExtendedCompositeParameters

      int getExtendedCompositeParameters(int size, IntBuffer pn, IntBuffer pextra, IntBuffer pactualsize)
      Original signature : l_ok getExtendedCompositeParameters(l_int32, l_int32*, l_int32*, l_int32*)
    • pixMorphSequence

      Pix pixMorphSequence(Pix pixs, String sequence, int dispsep)
      Original signature : PIX* pixMorphSequence(PIX*, const char*, l_int32)
    • pixMorphCompSequence

      Pix pixMorphCompSequence(Pix pixs, String sequence, int dispsep)
      Original signature : PIX* pixMorphCompSequence(PIX*, const char*, l_int32)
    • pixMorphSequenceDwa

      Pix pixMorphSequenceDwa(Pix pixs, String sequence, int dispsep)
      Original signature : PIX* pixMorphSequenceDwa(PIX*, const char*, l_int32)
    • pixMorphCompSequenceDwa

      Pix pixMorphCompSequenceDwa(Pix pixs, String sequence, int dispsep)
      Original signature : PIX* pixMorphCompSequenceDwa(PIX*, const char*, l_int32)
    • morphSequenceVerify

      int morphSequenceVerify(Sarray sa)
      Original signature : l_int32 morphSequenceVerify(SARRAY*)
    • pixGrayMorphSequence

      Pix pixGrayMorphSequence(Pix pixs, String sequence, int dispsep, int dispy)
      Original signature : PIX* pixGrayMorphSequence(PIX*, const char*, l_int32, l_int32)
    • pixColorMorphSequence

      Pix pixColorMorphSequence(Pix pixs, String sequence, int dispsep, int dispy)
      Original signature : PIX* pixColorMorphSequence(PIX*, const char*, l_int32, l_int32)
    • numaReadMem

      Numa numaReadMem(ByteBuffer data, NativeSize size)
      Original signature : NUMA* numaReadMem(const l_uint8*, size_t)
    • numaWrite

      int numaWrite(String filename, Numa na)
      Original signature : l_ok numaWrite(const char*, NUMA*)
    • numaWriteMem

      int numaWriteMem(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, Numa na)
      Original signature : l_ok numaWriteMem(l_uint8**, size_t*, NUMA*)
    • numaaCreate

      Numaa numaaCreate(int n)
      Original signature : NUMAA* numaaCreate(l_int32)
    • numaaCreateFull

      Numaa numaaCreateFull(int nptr, int n)
      Original signature : NUMAA* numaaCreateFull(l_int32, l_int32)
    • numaaTruncate

      int numaaTruncate(Numaa naa)
      Original signature : l_ok numaaTruncate(NUMAA*)
    • numaaDestroy

      void numaaDestroy(com.sun.jna.ptr.PointerByReference pnaa)
      Original signature : void numaaDestroy(NUMAA**)
    • numaaAddNuma

      int numaaAddNuma(Numaa naa, Numa na, int copyflag)
      Original signature : l_ok numaaAddNuma(NUMAA*, NUMA*, l_int32)
    • numaaGetCount

      int numaaGetCount(Numaa naa)
      Original signature : l_int32 numaaGetCount(NUMAA*)
    • numaaGetNumaCount

      int numaaGetNumaCount(Numaa naa, int index)
      Original signature : l_int32 numaaGetNumaCount(NUMAA*, l_int32)
    • numaaGetNumberCount

      int numaaGetNumberCount(Numaa naa)
      Original signature : l_int32 numaaGetNumberCount(NUMAA*)
    • numaaReadMem

      Numaa numaaReadMem(ByteBuffer data, NativeSize size)
      Original signature : NUMAA* numaaReadMem(const l_uint8*, size_t)
    • numaaWriteMem

      int numaaWriteMem(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, Numaa naa)
      Original signature : l_ok numaaWriteMem(l_uint8**, size_t*, NUMAA*)
    • numaSimpleStats

      int numaSimpleStats(Numa na, int first, int last, FloatBuffer pmean, FloatBuffer pvar, FloatBuffer prvar)
      Original signature : l_ok numaSimpleStats(NUMA*, l_int32, l_int32, l_float32*, l_float32*, l_float32*)
    • grayHistogramsToEMD

      int grayHistogramsToEMD(Numaa naa1, Numaa naa2, com.sun.jna.ptr.PointerByReference pnad)
      Original signature : l_ok grayHistogramsToEMD(NUMAA*, NUMAA*, NUMA**)
    • grayInterHistogramStats

      int grayInterHistogramStats(Numaa naa, int wc, com.sun.jna.ptr.PointerByReference pnam, com.sun.jna.ptr.PointerByReference pnams, com.sun.jna.ptr.PointerByReference pnav, com.sun.jna.ptr.PointerByReference pnarv)
      Original signature : l_ok grayInterHistogramStats(NUMAA*, l_int32, NUMA**, NUMA**, NUMA**, NUMA**)
    • genConstrainedNumaInRange

      Numa genConstrainedNumaInRange(int first, int last, int nmax, int use_pairs)
      Original signature : NUMA* genConstrainedNumaInRange(l_int32, l_int32, l_int32, l_int32)
    • pixGetRegionsBinary

      int pixGetRegionsBinary(Pix pixs, com.sun.jna.ptr.PointerByReference ppixhm, com.sun.jna.ptr.PointerByReference ppixtm, com.sun.jna.ptr.PointerByReference ppixtb, Pixa pixadb)
      Original signature : l_ok pixGetRegionsBinary(PIX*, PIX**, PIX**, PIX**, PIXA*)
    • pixGenHalftoneMask

      Pix pixGenHalftoneMask(Pix pixs, com.sun.jna.ptr.PointerByReference ppixtext, IntBuffer phtfound, int debug)
      Original signature : PIX* pixGenHalftoneMask(PIX*, PIX**, l_int32*, l_int32)
    • pixGenHalftoneMask

      Pix pixGenHalftoneMask(Pix pixs, com.sun.jna.ptr.PointerByReference ppixtext, com.sun.jna.ptr.IntByReference phtfound, int debug)
      Original signature : PIX* pixGenHalftoneMask(PIX*, PIX**, l_int32*, l_int32)
    • pixGenerateHalftoneMask

      Pix pixGenerateHalftoneMask(Pix pixs, com.sun.jna.ptr.PointerByReference ppixtext, IntBuffer phtfound, Pixa pixadb)
      Original signature : PIX* pixGenerateHalftoneMask(PIX*, PIX**, l_int32*, PIXA*)
    • pixGenerateHalftoneMask

      Pix pixGenerateHalftoneMask(Pix pixs, com.sun.jna.ptr.PointerByReference ppixtext, com.sun.jna.ptr.IntByReference phtfound, Pixa pixadb)
      Original signature : PIX* pixGenerateHalftoneMask(PIX*, PIX**, l_int32*, PIXA*)
    • pixGenTextlineMask

      Pix pixGenTextlineMask(Pix pixs, com.sun.jna.ptr.PointerByReference ppixvws, IntBuffer ptlfound, Pixa pixadb)
      Original signature : PIX* pixGenTextlineMask(PIX*, PIX**, l_int32*, PIXA*)
    • pixGenTextlineMask

      Pix pixGenTextlineMask(Pix pixs, com.sun.jna.ptr.PointerByReference ppixvws, com.sun.jna.ptr.IntByReference ptlfound, Pixa pixadb)
      Original signature : PIX* pixGenTextlineMask(PIX*, PIX**, l_int32*, PIXA*)
    • pixGenTextblockMask

      Pix pixGenTextblockMask(Pix pixs, Pix pixvws, Pixa pixadb)
      Original signature : PIX* pixGenTextblockMask(PIX*, PIX*, PIXA*)
    • pixFindPageForeground

      Box pixFindPageForeground(Pix pixs, int threshold, int mindist, int erasedist, int showmorph, PixaComp pixac)
      Original signature : BOX* pixFindPageForeground(PIX*, l_int32, l_int32, l_int32, l_int32, PIXAC*)
    • pixSplitIntoCharacters

      int pixSplitIntoCharacters(Pix pixs, int minw, int minh, com.sun.jna.ptr.PointerByReference pboxa, com.sun.jna.ptr.PointerByReference ppixa, com.sun.jna.ptr.PointerByReference ppixdebug)
      Original signature : l_ok pixSplitIntoCharacters(PIX*, l_int32, l_int32, BOXA**, PIXA**, PIX**)
    • pixSplitComponentWithProfile

      Boxa pixSplitComponentWithProfile(Pix pixs, int delta, int mindel, com.sun.jna.ptr.PointerByReference ppixdebug)
      Original signature : BOXA* pixSplitComponentWithProfile(PIX*, l_int32, l_int32, PIX**)
    • pixExtractTextlines

      Pixa pixExtractTextlines(Pix pixs, int maxw, int maxh, int minw, int minh, int adjw, int adjh, Pixa pixadb)
      Original signature : PIXA* pixExtractTextlines(PIX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, PIXA*)
    • pixExtractRawTextlines

      Pixa pixExtractRawTextlines(Pix pixs, int maxw, int maxh, int adjw, int adjh, Pixa pixadb)
      Original signature : PIXA* pixExtractRawTextlines(PIX*, l_int32, l_int32, l_int32, l_int32, PIXA*)
    • pixCountTextColumns

      int pixCountTextColumns(Pix pixs, float deltafract, float peakfract, float clipfract, IntBuffer pncols, Pixa pixadb)
      Original signature : l_ok pixCountTextColumns(PIX*, l_float32, l_float32, l_float32, l_int32*, PIXA*)
    • pixDecideIfText

      int pixDecideIfText(Pix pixs, Box box, IntBuffer pistext, Pixa pixadb)
      Original signature : l_ok pixDecideIfText(PIX*, BOX*, l_int32*, PIXA*)
    • pixFindThreshFgExtent

      int pixFindThreshFgExtent(Pix pixs, int thresh, IntBuffer ptop, IntBuffer pbot)
      Original signature : l_ok pixFindThreshFgExtent(PIX*, l_int32, l_int32*, l_int32*)
    • pixDecideIfTable

      int pixDecideIfTable(Pix pixs, Box box, IntBuffer pistable, Pixa pixadb)
      Original signature : l_ok pixDecideIfTable(PIX*, BOX*, l_int32*, PIXA*)
    • pixPrepare1bpp

      Pix pixPrepare1bpp(Pix pixs, Box box, float cropfract, int outres)
      Original signature : PIX* pixPrepare1bpp(PIX*, BOX*, l_float32, l_int32)
    • pixEstimateBackground

      int pixEstimateBackground(Pix pixs, int darkthresh, float edgecrop, IntBuffer pbg)
      Original signature : l_ok pixEstimateBackground(PIX*, l_int32, l_float32, l_int32*)
    • pixFindLargeRectangles

      int pixFindLargeRectangles(Pix pixs, int polarity, int nrect, com.sun.jna.ptr.PointerByReference pboxa, com.sun.jna.ptr.PointerByReference ppixdb)
      Original signature : l_ok pixFindLargeRectangles(PIX*, l_int32, l_int32, BOXA**, PIX**)
    • pixFindLargestRectangle

      int pixFindLargestRectangle(Pix pixs, int polarity, com.sun.jna.ptr.PointerByReference pbox, com.sun.jna.ptr.PointerByReference ppixdb)
      Original signature : l_ok pixFindLargestRectangle(PIX*, l_int32, BOX**, PIX**)
    • pixAutoPhotoinvert

      Pix pixAutoPhotoinvert(Pix pixs, int thresh, com.sun.jna.ptr.PointerByReference ppixm, Pixa pixadb)
      Original signature : PIX* pixAutoPhotoinvert(PIX*, l_int32, PIX**, PIXA*)
    • pixSetSelectCmap

      int pixSetSelectCmap(Pix pixs, Box box, int sindex, int rval, int gval, int bval)
      Original signature : l_ok pixSetSelectCmap(PIX*, BOX*, l_int32, l_int32, l_int32, l_int32)
    • pixColorGrayRegionsCmap

      int pixColorGrayRegionsCmap(Pix pixs, Boxa boxa, int type, int rval, int gval, int bval)
      Original signature : l_ok pixColorGrayRegionsCmap(PIX*, BOXA*, l_int32, l_int32, l_int32, l_int32)
    • pixColorGrayCmap

      int pixColorGrayCmap(Pix pixs, Box box, int type, int rval, int gval, int bval)
      Original signature : l_ok pixColorGrayCmap(PIX*, BOX*, l_int32, l_int32, l_int32, l_int32)
    • pixColorGrayMaskedCmap

      int pixColorGrayMaskedCmap(Pix pixs, Pix pixm, int type, int rval, int gval, int bval)
      Original signature : l_ok pixColorGrayMaskedCmap(PIX*, PIX*, l_int32, l_int32, l_int32, l_int32)
    • addColorizedGrayToCmap

      int addColorizedGrayToCmap(PixColormap cmap, int type, int rval, int gval, int bval, com.sun.jna.ptr.PointerByReference pna)
      Original signature : l_ok addColorizedGrayToCmap(PIXCMAP*, l_int32, l_int32, l_int32, l_int32, NUMA**)
    • pixSetSelectMaskedCmap

      int pixSetSelectMaskedCmap(Pix pixs, Pix pixm, int x, int y, int sindex, int rval, int gval, int bval)
      Original signature : l_ok pixSetSelectMaskedCmap(PIX*, PIX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixSetMaskedCmap

      int pixSetMaskedCmap(Pix pixs, Pix pixm, int x, int y, int rval, int gval, int bval)
      Original signature : l_ok pixSetMaskedCmap(PIX*, PIX*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • parseForProtos

      com.sun.jna.Pointer parseForProtos(String filein, String prestring)
      Original signature : char* parseForProtos(const char*, const char*)
    • boxaGetWhiteblocks

      Boxa boxaGetWhiteblocks(Boxa boxas, Box box, int sortflag, int maxboxes, float maxoverlap, int maxperim, float fract, int maxpops)
      Original signature : BOXA* boxaGetWhiteblocks(BOXA*, BOX*, l_int32, l_int32, l_float32, l_int32, l_float32, l_int32)
    • boxaPruneSortedOnOverlap

      Boxa boxaPruneSortedOnOverlap(Boxa boxas, float maxoverlap)
      Original signature : BOXA* boxaPruneSortedOnOverlap(BOXA*, l_float32)
    • convertFilesToPdf

      int convertFilesToPdf(String dirname, String substr, int res, float scalefactor, int type, int quality, String title, String fileout)
      Original signature : l_ok convertFilesToPdf(const char*, const char*, l_int32, l_float32, l_int32, l_int32, const char*, const char*)
    • saConvertFilesToPdf

      int saConvertFilesToPdf(Sarray sa, int res, float scalefactor, int type, int quality, String title, String fileout)
      Original signature : l_ok saConvertFilesToPdf(SARRAY*, l_int32, l_float32, l_int32, l_int32, const char*, const char*)
    • saConvertFilesToPdfData

      int saConvertFilesToPdfData(Sarray sa, int res, float scalefactor, int type, int quality, String title, com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference pnbytes)
      Original signature : l_ok saConvertFilesToPdfData(SARRAY*, l_int32, l_float32, l_int32, l_int32, const char*, l_uint8**, size_t*)
    • selectDefaultPdfEncoding

      int selectDefaultPdfEncoding(Pix pix, IntBuffer ptype)
      Original signature : l_ok selectDefaultPdfEncoding(PIX*, l_int32*)
    • convertUnscaledFilesToPdf

      int convertUnscaledFilesToPdf(String dirname, String substr, String title, String fileout)
      Original signature : l_ok convertUnscaledFilesToPdf(const char*, const char*, const char*, const char*)
    • saConvertUnscaledFilesToPdf

      int saConvertUnscaledFilesToPdf(Sarray sa, String title, String fileout)
      Original signature : l_ok saConvertUnscaledFilesToPdf(SARRAY*, const char*, const char*)
    • saConvertUnscaledFilesToPdfData

      int saConvertUnscaledFilesToPdfData(Sarray sa, String title, com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference pnbytes)
      Original signature : l_ok saConvertUnscaledFilesToPdfData(SARRAY*, const char*, l_uint8**, size_t*)
    • convertUnscaledToPdfData

      int convertUnscaledToPdfData(String fname, String title, com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference pnbytes)
      Original signature : l_ok convertUnscaledToPdfData(const char*, const char*, l_uint8**, size_t*)
    • pixaConvertToPdf

      int pixaConvertToPdf(Pixa pixa, int res, float scalefactor, int type, int quality, String title, String fileout)
      Original signature : l_ok pixaConvertToPdf(PIXA*, l_int32, l_float32, l_int32, l_int32, const char*, const char*)
    • pixaConvertToPdfData

      int pixaConvertToPdfData(Pixa pixa, int res, float scalefactor, int type, int quality, String title, com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference pnbytes)
      Original signature : l_ok pixaConvertToPdfData(PIXA*, l_int32, l_float32, l_int32, l_int32, const char*, l_uint8**, size_t*)
    • convertToPdf

      int convertToPdf(String filein, int type, int quality, String fileout, int x, int y, int res, String title, com.sun.jna.ptr.PointerByReference plpd, int position)
      Original signature : l_ok convertToPdf(const char*, l_int32, l_int32, const char*, l_int32, l_int32, l_int32, const char*, L_PDF_DATA**, l_int32)
    • convertToPdf

      int convertToPdf(com.sun.jna.Pointer filein, int type, int quality, com.sun.jna.Pointer fileout, int x, int y, int res, com.sun.jna.Pointer title, com.sun.jna.ptr.PointerByReference plpd, int position)
      Original signature : l_ok convertToPdf(const char*, l_int32, l_int32, const char*, l_int32, l_int32, l_int32, const char*, L_PDF_DATA**, l_int32)
    • convertImageDataToPdf

      int convertImageDataToPdf(ByteBuffer imdata, NativeSize size, int type, int quality, String fileout, int x, int y, int res, String title, com.sun.jna.ptr.PointerByReference plpd, int position)
      Original signature : l_ok convertImageDataToPdf(l_uint8*, size_t, l_int32, l_int32, const char*, l_int32, l_int32, l_int32, const char*, L_PDF_DATA**, l_int32)
    • convertImageDataToPdf

      int convertImageDataToPdf(com.sun.jna.Pointer imdata, NativeSize size, int type, int quality, com.sun.jna.Pointer fileout, int x, int y, int res, com.sun.jna.Pointer title, com.sun.jna.ptr.PointerByReference plpd, int position)
      Original signature : l_ok convertImageDataToPdf(l_uint8*, size_t, l_int32, l_int32, const char*, l_int32, l_int32, l_int32, const char*, L_PDF_DATA**, l_int32)
    • convertToPdfData

      int convertToPdfData(String filein, int type, int quality, com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference pnbytes, int x, int y, int res, String title, com.sun.jna.ptr.PointerByReference plpd, int position)
      Original signature : l_ok convertToPdfData(const char*, l_int32, l_int32, l_uint8**, size_t*, l_int32, l_int32, l_int32, const char*, L_PDF_DATA**, l_int32)
    • convertToPdfData

      int convertToPdfData(com.sun.jna.Pointer filein, int type, int quality, com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference pnbytes, int x, int y, int res, com.sun.jna.Pointer title, com.sun.jna.ptr.PointerByReference plpd, int position)
      Original signature : l_ok convertToPdfData(const char*, l_int32, l_int32, l_uint8**, size_t*, l_int32, l_int32, l_int32, const char*, L_PDF_DATA**, l_int32)
    • convertImageDataToPdfData

      int convertImageDataToPdfData(ByteBuffer imdata, NativeSize size, int type, int quality, com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference pnbytes, int x, int y, int res, String title, com.sun.jna.ptr.PointerByReference plpd, int position)
      Original signature : l_ok convertImageDataToPdfData(l_uint8*, size_t, l_int32, l_int32, l_uint8**, size_t*, l_int32, l_int32, l_int32, const char*, L_PDF_DATA**, l_int32)
    • convertImageDataToPdfData

      int convertImageDataToPdfData(com.sun.jna.Pointer imdata, NativeSize size, int type, int quality, com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference pnbytes, int x, int y, int res, com.sun.jna.Pointer title, com.sun.jna.ptr.PointerByReference plpd, int position)
      Original signature : l_ok convertImageDataToPdfData(l_uint8*, size_t, l_int32, l_int32, l_uint8**, size_t*, l_int32, l_int32, l_int32, const char*, L_PDF_DATA**, l_int32)
    • pixConvertToPdf

      int pixConvertToPdf(Pix pix, int type, int quality, String fileout, int x, int y, int res, String title, com.sun.jna.ptr.PointerByReference plpd, int position)
      Original signature : l_ok pixConvertToPdf(PIX*, l_int32, l_int32, const char*, l_int32, l_int32, l_int32, const char*, L_PDF_DATA**, l_int32)
    • pixConvertToPdf

      int pixConvertToPdf(Pix pix, int type, int quality, com.sun.jna.Pointer fileout, int x, int y, int res, com.sun.jna.Pointer title, com.sun.jna.ptr.PointerByReference plpd, int position)
      Original signature : l_ok pixConvertToPdf(PIX*, l_int32, l_int32, const char*, l_int32, l_int32, l_int32, const char*, L_PDF_DATA**, l_int32)
    • pixWriteMemPdf

      int pixWriteMemPdf(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference pnbytes, Pix pix, int res, String title)
      Original signature : l_ok pixWriteMemPdf(l_uint8**, size_t*, PIX*, l_int32, const char*)
    • convertSegmentedFilesToPdf

      int convertSegmentedFilesToPdf(String dirname, String substr, int res, int type, int thresh, Boxaa baa, int quality, float scalefactor, String title, String fileout)
      Original signature : l_ok convertSegmentedFilesToPdf(const char*, const char*, l_int32, l_int32, l_int32, BOXAA*, l_int32, l_float32, const char*, const char*)
    • convertNumberedMasksToBoxaa

      Boxaa convertNumberedMasksToBoxaa(String dirname, String substr, int numpre, int numpost)
      Original signature : BOXAA* convertNumberedMasksToBoxaa(const char*, const char*, l_int32, l_int32)
    • convertToPdfSegmented

      int convertToPdfSegmented(String filein, int res, int type, int thresh, Boxa boxa, int quality, float scalefactor, String title, String fileout)
      Original signature : l_ok convertToPdfSegmented(const char*, l_int32, l_int32, l_int32, BOXA*, l_int32, l_float32, const char*, const char*)
    • pixConvertToPdfSegmented

      int pixConvertToPdfSegmented(Pix pixs, int res, int type, int thresh, Boxa boxa, int quality, float scalefactor, String title, String fileout)
      Original signature : l_ok pixConvertToPdfSegmented(PIX*, l_int32, l_int32, l_int32, BOXA*, l_int32, l_float32, const char*, const char*)
    • convertToPdfDataSegmented

      int convertToPdfDataSegmented(String filein, int res, int type, int thresh, Boxa boxa, int quality, float scalefactor, String title, com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference pnbytes)
      Original signature : l_ok convertToPdfDataSegmented(const char*, l_int32, l_int32, l_int32, BOXA*, l_int32, l_float32, const char*, l_uint8**, size_t*)
    • pixConvertToPdfDataSegmented

      int pixConvertToPdfDataSegmented(Pix pixs, int res, int type, int thresh, Boxa boxa, int quality, float scalefactor, String title, com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference pnbytes)
      Original signature : l_ok pixConvertToPdfDataSegmented(PIX*, l_int32, l_int32, l_int32, BOXA*, l_int32, l_float32, const char*, l_uint8**, size_t*)
    • concatenatePdf

      int concatenatePdf(String dirname, String substr, String fileout)
      Original signature : l_ok concatenatePdf(const char*, const char*, const char*)
    • saConcatenatePdf

      int saConcatenatePdf(Sarray sa, String fileout)
      Original signature : l_ok saConcatenatePdf(SARRAY*, const char*)
    • ptraConcatenatePdf

      int ptraConcatenatePdf(L_Ptra pa, String fileout)
      Original signature : l_ok ptraConcatenatePdf(L_PTRA*, const char*)
    • concatenatePdfToData

      int concatenatePdfToData(String dirname, String substr, com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference pnbytes)
      Original signature : l_ok concatenatePdfToData(const char*, const char*, l_uint8**, size_t*)
    • saConcatenatePdfToData

      int saConcatenatePdfToData(Sarray sa, com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference pnbytes)
      Original signature : l_ok saConcatenatePdfToData(SARRAY*, l_uint8**, size_t*)
    • pixConvertToPdfData

      int pixConvertToPdfData(Pix pix, int type, int quality, com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference pnbytes, int x, int y, int res, String title, com.sun.jna.ptr.PointerByReference plpd, int position)
      Original signature : l_ok pixConvertToPdfData(PIX*, l_int32, l_int32, l_uint8**, size_t*, l_int32, l_int32, l_int32, const char*, L_PDF_DATA**, l_int32)
    • pixConvertToPdfData

      int pixConvertToPdfData(Pix pix, int type, int quality, com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference pnbytes, int x, int y, int res, com.sun.jna.Pointer title, com.sun.jna.ptr.PointerByReference plpd, int position)
      Original signature : l_ok pixConvertToPdfData(PIX*, l_int32, l_int32, l_uint8**, size_t*, l_int32, l_int32, l_int32, const char*, L_PDF_DATA**, l_int32)
    • ptraConcatenatePdfToData

      int ptraConcatenatePdfToData(L_Ptra pa_data, Sarray sa, com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference pnbytes)
      Original signature : l_ok ptraConcatenatePdfToData(L_PTRA*, SARRAY*, l_uint8**, size_t*)
    • convertTiffMultipageToPdf

      int convertTiffMultipageToPdf(String filein, String fileout)
      Original signature : l_ok convertTiffMultipageToPdf(const char*, const char*)
    • l_generateCIDataForPdf

      int l_generateCIDataForPdf(String fname, Pix pix, int quality, com.sun.jna.ptr.PointerByReference pcid)
      Original signature : l_ok l_generateCIDataForPdf(const char*, PIX*, l_int32, L_COMP_DATA**)
    • l_generateCIDataForPdf

      int l_generateCIDataForPdf(com.sun.jna.Pointer fname, Pix pix, int quality, com.sun.jna.ptr.PointerByReference pcid)
      Original signature : l_ok l_generateCIDataForPdf(const char*, PIX*, l_int32, L_COMP_DATA**)
    • l_generateFlateDataPdf

      L_Compressed_Data l_generateFlateDataPdf(String fname, Pix pixs)
      Original signature : L_COMP_DATA* l_generateFlateDataPdf(const char*, PIX*)
    • l_generateJpegData

      L_Compressed_Data l_generateJpegData(String fname, int ascii85flag)
      Original signature : L_COMP_DATA* l_generateJpegData(const char*, l_int32)
    • l_generateCIData

      int l_generateCIData(String fname, int type, int quality, int ascii85, com.sun.jna.ptr.PointerByReference pcid)
      Original signature : l_ok l_generateCIData(const char*, l_int32, l_int32, l_int32, L_COMP_DATA**)
    • l_generateCIData

      int l_generateCIData(com.sun.jna.Pointer fname, int type, int quality, int ascii85, com.sun.jna.ptr.PointerByReference pcid)
      Original signature : l_ok l_generateCIData(const char*, l_int32, l_int32, l_int32, L_COMP_DATA**)
    • pixGenerateCIData

      int pixGenerateCIData(Pix pixs, int type, int quality, int ascii85, com.sun.jna.ptr.PointerByReference pcid)
      Original signature : l_ok pixGenerateCIData(PIX*, l_int32, l_int32, l_int32, L_COMP_DATA**)
    • l_generateFlateData

      L_Compressed_Data l_generateFlateData(String fname, int ascii85flag)
      Original signature : L_COMP_DATA* l_generateFlateData(const char*, l_int32)
    • l_generateG4Data

      L_Compressed_Data l_generateG4Data(String fname, int ascii85flag)
      Original signature : L_COMP_DATA* l_generateG4Data(const char*, l_int32)
    • cidConvertToPdfData

      int cidConvertToPdfData(L_Compressed_Data cid, String title, com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference pnbytes)
      Original signature : l_ok cidConvertToPdfData(L_COMP_DATA*, const char*, l_uint8**, size_t*)
    • l_CIDataDestroy

      void l_CIDataDestroy(com.sun.jna.ptr.PointerByReference pcid)
      Original signature : void l_CIDataDestroy(L_COMP_DATA**)
    • l_pdfSetG4ImageMask

      void l_pdfSetG4ImageMask(int flag)
      Original signature : void l_pdfSetG4ImageMask(l_int32)
    • l_pdfSetDateAndVersion

      void l_pdfSetDateAndVersion(int flag)
      Original signature : void l_pdfSetDateAndVersion(l_int32)
    • setPixMemoryManager

      void setPixMemoryManager(ILeptonica.alloc_fn allocator, ILeptonica.dealloc_fn deallocator)
      Original signature : void setPixMemoryManager(alloc_fn, dealloc_fn)
    • pixCreate

      Pix pixCreate(int width, int height, int depth)
      Original signature : PIX* pixCreate(l_int32, l_int32, l_int32)
    • pixCreateNoInit

      Pix pixCreateNoInit(int width, int height, int depth)
      Original signature : PIX* pixCreateNoInit(l_int32, l_int32, l_int32)
    • pixCreateTemplate

      Pix pixCreateTemplate(Pix pixs)
      Original signature : PIX* pixCreateTemplate(PIX*)
    • pixCreateTemplateNoInit

      Pix pixCreateTemplateNoInit(Pix pixs)
      Original signature : PIX* pixCreateTemplateNoInit(PIX*)
    • pixCreateHeader

      Pix pixCreateHeader(int width, int height, int depth)
      Original signature : PIX* pixCreateHeader(l_int32, l_int32, l_int32)
    • pixClone

      Pix pixClone(Pix pixs)
      Original signature : PIX* pixClone(PIX*)
    • pixDestroy

      void pixDestroy(com.sun.jna.ptr.PointerByReference ppix)
      Original signature : void pixDestroy(PIX**)
    • pixCopy

      Pix pixCopy(Pix pixd, Pix pixs)
      Original signature : PIX* pixCopy(PIX*, PIX*)
    • pixResizeImageData

      int pixResizeImageData(Pix pixd, Pix pixs)
      Original signature : l_ok pixResizeImageData(PIX*, PIX*)
    • pixCopyColormap

      int pixCopyColormap(Pix pixd, Pix pixs)
      Original signature : l_ok pixCopyColormap(PIX*, PIX*)
    • pixTransferAllData

      int pixTransferAllData(Pix pixd, com.sun.jna.ptr.PointerByReference ppixs, int copytext, int copyformat)
      Original signature : l_ok pixTransferAllData(PIX*, PIX**, l_int32, l_int32)
    • pixSwapAndDestroy

      int pixSwapAndDestroy(com.sun.jna.ptr.PointerByReference ppixd, com.sun.jna.ptr.PointerByReference ppixs)
      Original signature : l_ok pixSwapAndDestroy(PIX**, PIX**)
    • pixGetWidth

      int pixGetWidth(Pix pix)
      Original signature : l_int32 pixGetWidth(PIX*)
    • pixSetWidth

      int pixSetWidth(Pix pix, int width)
      Original signature : l_int32 pixSetWidth(PIX*, l_int32)
    • pixGetHeight

      int pixGetHeight(Pix pix)
      Original signature : l_int32 pixGetHeight(PIX*)
    • pixSetHeight

      int pixSetHeight(Pix pix, int height)
      Original signature : l_int32 pixSetHeight(PIX*, l_int32)
    • pixGetDepth

      int pixGetDepth(Pix pix)
      Original signature : l_int32 pixGetDepth(PIX*)
    • pixSetDepth

      int pixSetDepth(Pix pix, int depth)
      Original signature : l_int32 pixSetDepth(PIX*, l_int32)
    • pixGetDimensions

      int pixGetDimensions(Pix pix, IntBuffer pw, IntBuffer ph, IntBuffer pd)
      Original signature : l_ok pixGetDimensions(PIX*, l_int32*, l_int32*, l_int32*)
    • pixSetDimensions

      int pixSetDimensions(Pix pix, int w, int h, int d)
      Original signature : l_ok pixSetDimensions(PIX*, l_int32, l_int32, l_int32)
    • pixCopyDimensions

      int pixCopyDimensions(Pix pixd, Pix pixs)
      Original signature : l_ok pixCopyDimensions(PIX*, PIX*)
    • pixGetSpp

      int pixGetSpp(Pix pix)
      Original signature : l_int32 pixGetSpp(PIX*)
    • pixSetSpp

      int pixSetSpp(Pix pix, int spp)
      Original signature : l_int32 pixSetSpp(PIX*, l_int32)
    • pixCopySpp

      int pixCopySpp(Pix pixd, Pix pixs)
      Original signature : l_ok pixCopySpp(PIX*, PIX*)
    • pixGetWpl

      int pixGetWpl(Pix pix)
      Original signature : l_int32 pixGetWpl(PIX*)
    • pixSetWpl

      int pixSetWpl(Pix pix, int wpl)
      Original signature : l_int32 pixSetWpl(PIX*, l_int32)
    • pixGetRefcount

      int pixGetRefcount(Pix pix)
      Original signature : l_int32 pixGetRefcount(PIX*)
    • pixChangeRefcount

      int pixChangeRefcount(Pix pix, int delta)
      Original signature : l_int32 pixChangeRefcount(PIX*, l_int32)
    • pixGetXRes

      int pixGetXRes(Pix pix)
      Original signature : l_int32 pixGetXRes(PIX*)
    • pixSetXRes

      int pixSetXRes(Pix pix, int res)
      Original signature : l_int32 pixSetXRes(PIX*, l_int32)
    • pixGetYRes

      int pixGetYRes(Pix pix)
      Original signature : l_int32 pixGetYRes(PIX*)
    • pixSetYRes

      int pixSetYRes(Pix pix, int res)
      Original signature : l_int32 pixSetYRes(PIX*, l_int32)
    • pixGetResolution

      int pixGetResolution(Pix pix, IntBuffer pxres, IntBuffer pyres)
      Original signature : l_ok pixGetResolution(PIX*, l_int32*, l_int32*)
    • pixSetResolution

      int pixSetResolution(Pix pix, int xres, int yres)
      Original signature : l_ok pixSetResolution(PIX*, l_int32, l_int32)
    • pixCopyResolution

      int pixCopyResolution(Pix pixd, Pix pixs)
      Original signature : l_int32 pixCopyResolution(PIX*, PIX*)
    • pixScaleResolution

      int pixScaleResolution(Pix pix, float xscale, float yscale)
      Original signature : l_int32 pixScaleResolution(PIX*, l_float32, l_float32)
    • pixGetInputFormat

      int pixGetInputFormat(Pix pix)
      Original signature : l_int32 pixGetInputFormat(PIX*)
    • pixSetInputFormat

      int pixSetInputFormat(Pix pix, int informat)
      Original signature : l_int32 pixSetInputFormat(PIX*, l_int32)
    • pixCopyInputFormat

      int pixCopyInputFormat(Pix pixd, Pix pixs)
      Original signature : l_int32 pixCopyInputFormat(PIX*, PIX*)
    • pixSetSpecial

      int pixSetSpecial(Pix pix, int special)
      Original signature : l_int32 pixSetSpecial(PIX*, l_int32)
    • pixGetText

      com.sun.jna.Pointer pixGetText(Pix pix)
      Original signature : char* pixGetText(PIX*)
    • pixSetText

      int pixSetText(Pix pix, String textstring)
      Original signature : l_ok pixSetText(PIX*, const char*)
    • pixAddText

      int pixAddText(Pix pix, String textstring)
      Original signature : l_ok pixAddText(PIX*, const char*)
    • pixCopyText

      int pixCopyText(Pix pixd, Pix pixs)
      Original signature : l_int32 pixCopyText(PIX*, PIX*)
    • pixGetColormap

      PixColormap pixGetColormap(Pix pix)
      Original signature : PIXCMAP* pixGetColormap(PIX*)
    • pixSetColormap

      int pixSetColormap(Pix pix, PixColormap colormap)
      Original signature : l_ok pixSetColormap(PIX*, PIXCMAP*)
    • pixDestroyColormap

      int pixDestroyColormap(Pix pix)
      Original signature : l_ok pixDestroyColormap(PIX*)
    • pixGetData

      com.sun.jna.ptr.IntByReference pixGetData(Pix pix)
      Original signature : l_uint32* pixGetData(PIX*)
    • pixSetData

      int pixSetData(Pix pix, IntBuffer data)
      Original signature : l_int32 pixSetData(PIX*, l_uint32*)
    • pixExtractData

      com.sun.jna.ptr.IntByReference pixExtractData(Pix pixs)
      Original signature : l_uint32* pixExtractData(PIX*)
    • pixFreeData

      int pixFreeData(Pix pix)
      Original signature : l_int32 pixFreeData(PIX*)
    • pixGetLinePtrs

      com.sun.jna.ptr.PointerByReference pixGetLinePtrs(Pix pix, IntBuffer psize)
      Original signature : void** pixGetLinePtrs(PIX*, l_int32*)
    • pixGetPixel

      int pixGetPixel(Pix pix, int x, int y, IntBuffer pval)
      Original signature : l_ok pixGetPixel(PIX*, l_int32, l_int32, l_uint32*)
    • pixSetPixel

      int pixSetPixel(Pix pix, int x, int y, int val)
      Original signature : l_ok pixSetPixel(PIX*, l_int32, l_int32, l_uint32)
    • pixGetRGBPixel

      int pixGetRGBPixel(Pix pix, int x, int y, IntBuffer prval, IntBuffer pgval, IntBuffer pbval)
      Original signature : l_ok pixGetRGBPixel(PIX*, l_int32, l_int32, l_int32*, l_int32*, l_int32*)
    • pixSetRGBPixel

      int pixSetRGBPixel(Pix pix, int x, int y, int rval, int gval, int bval)
      Original signature : l_ok pixSetRGBPixel(PIX*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixGetRandomPixel

      int pixGetRandomPixel(Pix pix, IntBuffer pval, IntBuffer px, IntBuffer py)
      Original signature : l_ok pixGetRandomPixel(PIX*, l_uint32*, l_int32*, l_int32*)
    • pixClearPixel

      int pixClearPixel(Pix pix, int x, int y)
      Original signature : l_ok pixClearPixel(PIX*, l_int32, l_int32)
    • pixFlipPixel

      int pixFlipPixel(Pix pix, int x, int y)
      Original signature : l_ok pixFlipPixel(PIX*, l_int32, l_int32)
    • setPixelLow

      void setPixelLow(IntBuffer line, int x, int depth, int val)
      Original signature : void setPixelLow(l_uint32*, l_int32, l_int32, l_uint32)
    • pixGetBlackOrWhiteVal

      int pixGetBlackOrWhiteVal(Pix pixs, int op, IntBuffer pval)
      Original signature : l_ok pixGetBlackOrWhiteVal(PIX*, l_int32, l_uint32*)
    • pixClearAll

      int pixClearAll(Pix pix)
      Original signature : l_ok pixClearAll(PIX*)
    • pixSetAll

      int pixSetAll(Pix pix)
      Original signature : l_ok pixSetAll(PIX*)
    • pixSetAllGray

      int pixSetAllGray(Pix pix, int grayval)
      Original signature : l_ok pixSetAllGray(PIX*, l_int32)
    • pixSetAllArbitrary

      int pixSetAllArbitrary(Pix pix, int val)
      Original signature : l_ok pixSetAllArbitrary(PIX*, l_uint32)
    • pixSetBlackOrWhite

      int pixSetBlackOrWhite(Pix pixs, int op)
      Original signature : l_ok pixSetBlackOrWhite(PIX*, l_int32)
    • pixSetComponentArbitrary

      int pixSetComponentArbitrary(Pix pix, int comp, int val)
      Original signature : l_ok pixSetComponentArbitrary(PIX*, l_int32, l_int32)
    • pixClearInRect

      int pixClearInRect(Pix pix, Box box)
      Original signature : l_ok pixClearInRect(PIX*, BOX*)
    • pixSetInRect

      int pixSetInRect(Pix pix, Box box)
      Original signature : l_ok pixSetInRect(PIX*, BOX*)
    • pixSetInRectArbitrary

      int pixSetInRectArbitrary(Pix pix, Box box, int val)
      Original signature : l_ok pixSetInRectArbitrary(PIX*, BOX*, l_uint32)
    • pixBlendInRect

      int pixBlendInRect(Pix pixs, Box box, int val, float fract)
      Original signature : l_ok pixBlendInRect(PIX*, BOX*, l_uint32, l_float32)
    • pixSetPadBits

      int pixSetPadBits(Pix pix, int val)
      Original signature : l_ok pixSetPadBits(PIX*, l_int32)
    • pixSetPadBitsBand

      int pixSetPadBitsBand(Pix pix, int by, int bh, int val)
      Original signature : l_ok pixSetPadBitsBand(PIX*, l_int32, l_int32, l_int32)
    • pixSetOrClearBorder

      int pixSetOrClearBorder(Pix pixs, int left, int right, int top, int bot, int op)
      Original signature : l_ok pixSetOrClearBorder(PIX*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixSetBorderVal

      int pixSetBorderVal(Pix pixs, int left, int right, int top, int bot, int val)
      Original signature : l_ok pixSetBorderVal(PIX*, l_int32, l_int32, l_int32, l_int32, l_uint32)
    • pixSetBorderRingVal

      int pixSetBorderRingVal(Pix pixs, int dist, int val)
      Original signature : l_ok pixSetBorderRingVal(PIX*, l_int32, l_uint32)
    • pixSetMirroredBorder

      int pixSetMirroredBorder(Pix pixs, int left, int right, int top, int bot)
      Original signature : l_ok pixSetMirroredBorder(PIX*, l_int32, l_int32, l_int32, l_int32)
    • pixCopyBorder

      Pix pixCopyBorder(Pix pixd, Pix pixs, int left, int right, int top, int bot)
      Original signature : PIX* pixCopyBorder(PIX*, PIX*, l_int32, l_int32, l_int32, l_int32)
    • pixAddBorder

      Pix pixAddBorder(Pix pixs, int npix, int val)
      Original signature : PIX* pixAddBorder(PIX*, l_int32, l_uint32)
    • pixAddBlackOrWhiteBorder

      Pix pixAddBlackOrWhiteBorder(Pix pixs, int left, int right, int top, int bot, int op)
      Original signature : PIX* pixAddBlackOrWhiteBorder(PIX*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixGetRGBLine

      int pixGetRGBLine(Pix pixs, int row, ByteBuffer bufr, ByteBuffer bufg, ByteBuffer bufb)
      Original signature : l_ok pixGetRGBLine(PIX*, l_int32, l_uint8*, l_uint8*, l_uint8*)
    • pixEndianByteSwapNew

      Pix pixEndianByteSwapNew(Pix pixs)
      Original signature : PIX* pixEndianByteSwapNew(PIX*)
    • pixEndianByteSwap

      int pixEndianByteSwap(Pix pixs)
      Original signature : l_ok pixEndianByteSwap(PIX*)
    • lineEndianByteSwap

      int lineEndianByteSwap(IntBuffer datad, IntBuffer datas, int wpl)
      Original signature : l_int32 lineEndianByteSwap(l_uint32*, l_uint32*, l_int32)
    • pixEndianTwoByteSwapNew

      Pix pixEndianTwoByteSwapNew(Pix pixs)
      Original signature : PIX* pixEndianTwoByteSwapNew(PIX*)
    • pixEndianTwoByteSwap

      int pixEndianTwoByteSwap(Pix pixs)
      Original signature : l_ok pixEndianTwoByteSwap(PIX*)
    • pixGetRasterData

      int pixGetRasterData(Pix pixs, com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference pnbytes)
      Original signature : l_ok pixGetRasterData(PIX*, l_uint8**, size_t*)
    • pixAlphaIsOpaque

      int pixAlphaIsOpaque(Pix pix, IntBuffer popaque)
      Original signature : l_ok pixAlphaIsOpaque(PIX*, l_int32*)
    • pixSetMasked

      int pixSetMasked(Pix pixd, Pix pixm, int val)
      Original signature : l_ok pixSetMasked(PIX*, PIX*, l_uint32)
    • pixSetMaskedGeneral

      int pixSetMaskedGeneral(Pix pixd, Pix pixm, int val, int x, int y)
      Original signature : l_ok pixSetMaskedGeneral(PIX*, PIX*, l_uint32, l_int32, l_int32)
    • pixCombineMasked

      int pixCombineMasked(Pix pixd, Pix pixs, Pix pixm)
      Original signature : l_ok pixCombineMasked(PIX*, PIX*, PIX*)
    • pixCombineMaskedGeneral

      int pixCombineMaskedGeneral(Pix pixd, Pix pixs, Pix pixm, int x, int y)
      Original signature : l_ok pixCombineMaskedGeneral(PIX*, PIX*, PIX*, l_int32, l_int32)
    • pixPaintThroughMask

      int pixPaintThroughMask(Pix pixd, Pix pixm, int x, int y, int val)
      Original signature : l_ok pixPaintThroughMask(PIX*, PIX*, l_int32, l_int32, l_uint32)
    • pixCopyWithBoxa

      Pix pixCopyWithBoxa(Pix pixs, Boxa boxa, int background)
      Original signature : PIX* pixCopyWithBoxa(PIX*, BOXA*, l_int32)
    • pixPaintSelfThroughMask

      int pixPaintSelfThroughMask(Pix pixd, Pix pixm, int x, int y, int searchdir, int mindist, int tilesize, int ntiles, int distblend)
      Original signature : l_ok pixPaintSelfThroughMask(PIX*, PIX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixMakeMaskFromVal

      Pix pixMakeMaskFromVal(Pix pixs, int val)
      Original signature : PIX* pixMakeMaskFromVal(PIX*, l_int32)
    • pixMakeMaskFromLUT

      Pix pixMakeMaskFromLUT(Pix pixs, IntBuffer tab)
      Original signature : PIX* pixMakeMaskFromLUT(PIX*, l_int32*)
    • pixMakeArbMaskFromRGB

      Pix pixMakeArbMaskFromRGB(Pix pixs, float rc, float gc, float bc, float thresh)
      Original signature : PIX* pixMakeArbMaskFromRGB(PIX*, l_float32, l_float32, l_float32, l_float32)
    • pixSetUnderTransparency

      Pix pixSetUnderTransparency(Pix pixs, int val, int debug)
      Original signature : PIX* pixSetUnderTransparency(PIX*, l_uint32, l_int32)
    • pixMakeAlphaFromMask

      Pix pixMakeAlphaFromMask(Pix pixs, int dist, com.sun.jna.ptr.PointerByReference pbox)
      Original signature : PIX* pixMakeAlphaFromMask(PIX*, l_int32, BOX**)
    • pixGetColorNearMaskBoundary

      int pixGetColorNearMaskBoundary(Pix pixs, Pix pixm, Box box, int dist, IntBuffer pval, int debug)
      Original signature : l_ok pixGetColorNearMaskBoundary(PIX*, PIX*, BOX*, l_int32, l_uint32*, l_int32)
    • pixInvert

      Pix pixInvert(Pix pixd, Pix pixs)
      Original signature : PIX* pixInvert(PIX*, PIX*)
    • pixOr

      Pix pixOr(Pix pixd, Pix pixs1, Pix pixs2)
      Original signature : PIX* pixOr(PIX*, PIX*, PIX*)
    • pixAnd

      Pix pixAnd(Pix pixd, Pix pixs1, Pix pixs2)
      Original signature : PIX* pixAnd(PIX*, PIX*, PIX*)
    • pixXor

      Pix pixXor(Pix pixd, Pix pixs1, Pix pixs2)
      Original signature : PIX* pixXor(PIX*, PIX*, PIX*)
    • pixSubtract

      Pix pixSubtract(Pix pixd, Pix pixs1, Pix pixs2)
      Original signature : PIX* pixSubtract(PIX*, PIX*, PIX*)
    • pixZero

      int pixZero(Pix pix, IntBuffer pempty)
      Original signature : l_ok pixZero(PIX*, l_int32*)
    • pixForegroundFraction

      int pixForegroundFraction(Pix pix, FloatBuffer pfract)
      Original signature : l_ok pixForegroundFraction(PIX*, l_float32*)
    • pixGetGrayHistogramTiled

      Numaa pixGetGrayHistogramTiled(Pix pixs, int factor, int nx, int ny)
      Original signature : NUMAA* pixGetGrayHistogramTiled(PIX*, l_int32, l_int32, l_int32)
    • pixCountRGBColorsByHash

      int pixCountRGBColorsByHash(Pix pixs, IntBuffer pncolors)
      Original signature : l_ok pixCountRGBColorsByHash(PIX*, l_int32*)
    • pixCountRGBColors

      int pixCountRGBColors(Pix pixs, int factor, IntBuffer pncolors)
      Original signature : l_ok pixCountRGBColors(PIX*, l_int32, l_int32*)
    • pixGetColorAmapHistogram

      L_Rbtree pixGetColorAmapHistogram(Pix pixs, int factor)
      Original signature : L_AMAP* pixGetColorAmapHistogram(PIX*, l_int32)
    • amapGetCountForColor

      int amapGetCountForColor(L_Rbtree amap, int val)
      Original signature : l_int32 amapGetCountForColor(L_AMAP*, l_uint32)
    • pixGetRangeValues

      int pixGetRangeValues(Pix pixs, int factor, int color, IntBuffer pminval, IntBuffer pmaxval)
      Original signature : l_ok pixGetRangeValues(PIX*, l_int32, l_int32, l_int32*, l_int32*)
    • pixGetMaxColorIndex

      int pixGetMaxColorIndex(Pix pixs, IntBuffer pmaxindex)
      Original signature : l_ok pixGetMaxColorIndex(PIX*, l_int32*)
    • pixGetBinnedComponentRange

      int pixGetBinnedComponentRange(Pix pixs, int nbins, int factor, int color, IntBuffer pminval, IntBuffer pmaxval, com.sun.jna.ptr.PointerByReference pcarray, int fontsize)
      Original signature : l_ok pixGetBinnedComponentRange(PIX*, l_int32, l_int32, l_int32, l_int32*, l_int32*, l_uint32**, l_int32)
    • pixGetRankColorArray

      int pixGetRankColorArray(Pix pixs, int nbins, int type, int factor, com.sun.jna.ptr.PointerByReference pcarray, Pixa pixadb, int fontsize)
      Original signature : l_ok pixGetRankColorArray(PIX*, l_int32, l_int32, l_int32, l_uint32**, PIXA*, l_int32)
    • pixDisplayColorArray

      Pix pixDisplayColorArray(IntBuffer carray, int ncolors, int side, int ncols, int fontsize)
      Original signature : PIX* pixDisplayColorArray(l_uint32*, l_int32, l_int32, l_int32, l_int32)
    • pixSplitDistributionFgBg

      int pixSplitDistributionFgBg(Pix pixs, float scorefract, int factor, com.sun.jna.ptr.IntByReference pthresh, com.sun.jna.ptr.IntByReference pfgval, com.sun.jna.ptr.IntByReference pbgval, com.sun.jna.ptr.PointerByReference ppixdb)
      Original signature : l_ok pixSplitDistributionFgBg(PIX*, l_float32, l_int32, l_int32*, l_int32*, l_int32*, PIX**)
    • pixClipRectangleWithBorder

      Pix pixClipRectangleWithBorder(Pix pixs, Box box, int maxbord, Box.ByReference[] pboxn)
      Original signature : PIX* pixClipRectangleWithBorder(PIX*, BOX*, l_int32, BOX**)
    • pixFractionFgInMask

      int pixFractionFgInMask(Pix pix1, Pix pix2, FloatBuffer pfract)
      Original signature : l_ok pixFractionFgInMask(PIX*, PIX*, l_float32*)
    • pixaCreate

      Pixa pixaCreate(int n)
      Original signature : PIXA* pixaCreate(l_int32)
    • pixaCreateFromPix

      Pixa pixaCreateFromPix(Pix pixs, int n, int cellw, int cellh)
      Original signature : PIXA* pixaCreateFromPix(PIX*, l_int32, l_int32, l_int32)
    • pixaCreateFromBoxa

      Pixa pixaCreateFromBoxa(Pix pixs, Boxa boxa, IntBuffer pcropwarn)
      Original signature : PIXA* pixaCreateFromBoxa(PIX*, BOXA*, l_int32*)
    • pixaDestroy

      void pixaDestroy(com.sun.jna.ptr.PointerByReference ppixa)
      Original signature : void pixaDestroy(PIXA**)
    • pixaCopy

      Pixa pixaCopy(Pixa pixa, int copyflag)
      Original signature : PIXA* pixaCopy(PIXA*, l_int32)
    • pixaAddPix

      int pixaAddPix(Pixa pixa, Pix pix, int copyflag)
      Original signature : l_ok pixaAddPix(PIXA*, PIX*, l_int32)
    • pixaAddBox

      int pixaAddBox(Pixa pixa, Box box, int copyflag)
      Original signature : l_ok pixaAddBox(PIXA*, BOX*, l_int32)
    • pixaGetCount

      int pixaGetCount(Pixa pixa)
      Original signature : l_int32 pixaGetCount(PIXA*)
    • pixaChangeRefcount

      int pixaChangeRefcount(Pixa pixa, int delta)
      Original signature : l_ok pixaChangeRefcount(PIXA*, l_int32)
    • pixaGetPix

      Pix pixaGetPix(Pixa pixa, int index, int accesstype)
      Original signature : PIX* pixaGetPix(PIXA*, l_int32, l_int32)
    • pixaGetPixDimensions

      int pixaGetPixDimensions(Pixa pixa, int index, IntBuffer pw, IntBuffer ph, IntBuffer pd)
      Original signature : l_ok pixaGetPixDimensions(PIXA*, l_int32, l_int32*, l_int32*, l_int32*)
    • pixaGetBoxa

      Boxa pixaGetBoxa(Pixa pixa, int accesstype)
      Original signature : BOXA* pixaGetBoxa(PIXA*, l_int32)
    • pixaGetBoxaCount

      int pixaGetBoxaCount(Pixa pixa)
      Original signature : l_int32 pixaGetBoxaCount(PIXA*)
    • pixaGetBox

      Box pixaGetBox(Pixa pixa, int index, int accesstype)
      Original signature : BOX* pixaGetBox(PIXA*, l_int32, l_int32)
    • pixaGetBoxGeometry

      int pixaGetBoxGeometry(Pixa pixa, int index, IntBuffer px, IntBuffer py, IntBuffer pw, IntBuffer ph)
      Original signature : l_ok pixaGetBoxGeometry(PIXA*, l_int32, l_int32*, l_int32*, l_int32*, l_int32*)
    • pixaSetBoxa

      int pixaSetBoxa(Pixa pixa, Boxa boxa, int accesstype)
      Original signature : l_ok pixaSetBoxa(PIXA*, BOXA*, l_int32)
    • pixaGetPixArray

      com.sun.jna.ptr.PointerByReference pixaGetPixArray(Pixa pixa)
      Original signature : PIX** pixaGetPixArray(PIXA*)
    • pixaSetText

      int pixaSetText(Pixa pixa, Sarray sa)
      Original signature : l_ok pixaSetText(PIXA*, SARRAY*)
    • pixaInterleave

      Pixa pixaInterleave(Pixa pixa1, Pixa pixa2, int copyflag)
      Original signature : PIXA* pixaInterleave(PIXA*, PIXA*, l_int32)
    • pixaReadMem

      Pixa pixaReadMem(ByteBuffer data, NativeSize size)
      Original signature : PIXA* pixaReadMem(const l_uint8*, size_t)
    • pixaWriteMem

      int pixaWriteMem(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, Pixa pixa)
      Original signature : l_ok pixaWriteMem(l_uint8**, size_t*, PIXA*)
    • pixaReadBoth

      Pixa pixaReadBoth(String filename)
      Original signature : PIXA* pixaReadBoth(const char*)
    • pixaaReadMem

      Pixaa pixaaReadMem(ByteBuffer data, NativeSize size)
      Original signature : PIXAA* pixaaReadMem(const l_uint8*, size_t)
    • pixaaWriteMem

      int pixaaWriteMem(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, Pixaa paa)
      Original signature : l_ok pixaaWriteMem(l_uint8**, size_t*, PIXAA*)
    • pixSelectByArea

      Pix pixSelectByArea(Pix pixs, float thresh, int connectivity, int type, IntBuffer pchanged)
      Original signature : PIX* pixSelectByArea(PIX*, l_float32, l_int32, l_int32, l_int32*)
    • pixaSelectByArea

      Pixa pixaSelectByArea(Pixa pixas, float thresh, int type, IntBuffer pchanged)
      Original signature : PIXA* pixaSelectByArea(PIXA*, l_float32, l_int32, l_int32*)
    • pixaSelectByNumConnComp

      Pixa pixaSelectByNumConnComp(Pixa pixas, int nmin, int nmax, int connectivity, IntBuffer pchanged)
      Original signature : PIXA* pixaSelectByNumConnComp(PIXA*, l_int32, l_int32, l_int32, l_int32*)
    • pixaSelectWithString

      Pixa pixaSelectWithString(Pixa pixas, String str, IntBuffer perror)
      Original signature : PIXA* pixaSelectWithString(PIXA*, const char*, l_int32*)
    • pixaScaleToSizeRel

      Pixa pixaScaleToSizeRel(Pixa pixas, int delw, int delh)
      Original signature : PIXA* pixaScaleToSizeRel(PIXA*, l_int32, l_int32)
    • pixaScale

      Pixa pixaScale(Pixa pixas, float scalex, float scaley)
      Original signature : PIXA* pixaScale(PIXA*, l_float32, l_float32)
    • pixaScaleBySampling

      Pixa pixaScaleBySampling(Pixa pixas, float scalex, float scaley)
      Original signature : PIXA* pixaScaleBySampling(PIXA*, l_float32, l_float32)
    • pixaRotate

      Pixa pixaRotate(Pixa pixas, float angle, int type, int incolor, int width, int height)
      Original signature : PIXA* pixaRotate(PIXA*, l_float32, l_int32, l_int32, l_int32, l_int32)
    • pixaRotateOrth

      Pixa pixaRotateOrth(Pixa pixas, int rotation)
      Original signature : PIXA* pixaRotateOrth(PIXA*, l_int32)
    • pixaTranslate

      Pixa pixaTranslate(Pixa pixas, int hshift, int vshift, int incolor)
      Original signature : PIXA* pixaTranslate(PIXA*, l_int32, l_int32, l_int32)
    • pixaClipToForeground

      int pixaClipToForeground(Pixa pixas, com.sun.jna.ptr.PointerByReference ppixad, com.sun.jna.ptr.PointerByReference pboxa)
      Original signature : l_ok pixaClipToForeground(PIXA*, PIXA**, BOXA**)
    • pixaSetFullSizeBoxa

      int pixaSetFullSizeBoxa(Pixa pixa)
      Original signature : l_ok pixaSetFullSizeBoxa(PIXA*)
    • pixaDisplayTiledInColumns

      Pix pixaDisplayTiledInColumns(Pixa pixas, int nx, float scalefactor, int spacing, int border)
      Original signature : PIX* pixaDisplayTiledInColumns(PIXA*, l_int32, l_float32, l_int32, l_int32)
    • pixaDisplayTiledWithText

      Pix pixaDisplayTiledWithText(Pixa pixa, int maxwidth, float scalefactor, int spacing, int border, int fontsize, int textcolor)
      Original signature : PIX* pixaDisplayTiledWithText(PIXA*, l_int32, l_float32, l_int32, l_int32, l_int32, l_uint32)
    • pixaDisplayTiledByIndex

      Pix pixaDisplayTiledByIndex(Pixa pixa, Numa na, int width, int spacing, int border, int fontsize, int textcolor)
      Original signature : PIX* pixaDisplayTiledByIndex(PIXA*, NUMA*, l_int32, l_int32, l_int32, l_int32, l_uint32)
    • pixaConstrainedSelect

      Pixa pixaConstrainedSelect(Pixa pixas, int first, int last, int nmax, int use_pairs, int copyflag)
      Original signature : PIXA* pixaConstrainedSelect(PIXA*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixaSelectToPdf

      int pixaSelectToPdf(Pixa pixas, int first, int last, int res, float scalefactor, int type, int quality, int color, int fontsize, String fileout)
      Original signature : l_ok pixaSelectToPdf(PIXA*, l_int32, l_int32, l_int32, l_float32, l_int32, l_int32, l_uint32, l_int32, const char*)
    • pixaDisplayMultiTiled

      Pixa pixaDisplayMultiTiled(Pixa pixas, int nx, int ny, int maxw, int maxh, float scalefactor, int spacing, int border)
      Original signature : PIXA* pixaDisplayMultiTiled(PIXA*, l_int32, l_int32, l_int32, l_int32, l_float32, l_int32, l_int32)
    • pixaSplitIntoFiles

      int pixaSplitIntoFiles(Pixa pixas, int nsplit, float scale, int outwidth, int write_pixa, int write_pix, int write_pdf)
      Original signature : l_ok pixaSplitIntoFiles(PIXA*, l_int32, l_float32, l_int32, l_int32, l_int32, l_int32)
    • pixaConvertToNUpPixa

      Pixa pixaConvertToNUpPixa(Pixa pixas, Sarray sa, int nx, int ny, int tw, int spacing, int border, int fontsize)
      Original signature : PIXA* pixaConvertToNUpPixa(PIXA*, SARRAY*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixaCompareInPdf

      int pixaCompareInPdf(Pixa pixa1, Pixa pixa2, int nx, int ny, int tw, int spacing, int border, int fontsize, String fileout)
      Original signature : l_ok pixaCompareInPdf(PIXA*, PIXA*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32, const char*)
    • pixAddConstantGray

      int pixAddConstantGray(Pix pixs, int val)
      Original signature : l_ok pixAddConstantGray(PIX*, l_int32)
    • pixMultConstantGray

      int pixMultConstantGray(Pix pixs, float val)
      Original signature : l_ok pixMultConstantGray(PIX*, l_float32)
    • pixAddGray

      Pix pixAddGray(Pix pixd, Pix pixs1, Pix pixs2)
      Original signature : PIX* pixAddGray(PIX*, PIX*, PIX*)
    • pixSubtractGray

      Pix pixSubtractGray(Pix pixd, Pix pixs1, Pix pixs2)
      Original signature : PIX* pixSubtractGray(PIX*, PIX*, PIX*)
    • pixMultiplyGray

      Pix pixMultiplyGray(Pix pixs, Pix pixg, float norm)
      Original signature : PIX* pixMultiplyGray(PIX*, PIX*, l_float32)
    • pixThresholdToValue

      Pix pixThresholdToValue(Pix pixd, Pix pixs, int threshval, int setval)
      Original signature : PIX* pixThresholdToValue(PIX*, PIX*, l_int32, l_int32)
    • pixInitAccumulate

      Pix pixInitAccumulate(int w, int h, int offset)
      Original signature : PIX* pixInitAccumulate(l_int32, l_int32, l_uint32)
    • pixFinalAccumulate

      Pix pixFinalAccumulate(Pix pixs, int offset, int depth)
      Original signature : PIX* pixFinalAccumulate(PIX*, l_uint32, l_int32)
    • pixFinalAccumulateThreshold

      Pix pixFinalAccumulateThreshold(Pix pixs, int offset, int threshold)
      Original signature : PIX* pixFinalAccumulateThreshold(PIX*, l_uint32, l_uint32)
    • pixAccumulate

      int pixAccumulate(Pix pixd, Pix pixs, int op)
      Original signature : l_ok pixAccumulate(PIX*, PIX*, l_int32)
    • pixMultConstAccumulate

      int pixMultConstAccumulate(Pix pixs, float factor, int offset)
      Original signature : l_ok pixMultConstAccumulate(PIX*, l_float32, l_uint32)
    • pixAbsDifference

      Pix pixAbsDifference(Pix pixs1, Pix pixs2)
      Original signature : PIX* pixAbsDifference(PIX*, PIX*)
    • pixAddRGB

      Pix pixAddRGB(Pix pixs1, Pix pixs2)
      Original signature : PIX* pixAddRGB(PIX*, PIX*)
    • pixMinOrMax

      Pix pixMinOrMax(Pix pixd, Pix pixs1, Pix pixs2, int type)
      Original signature : PIX* pixMinOrMax(PIX*, PIX*, PIX*, l_int32)
    • pixMaxDynamicRange

      Pix pixMaxDynamicRange(Pix pixs, int type)
      Original signature : PIX* pixMaxDynamicRange(PIX*, l_int32)
    • pixMaxDynamicRangeRGB

      Pix pixMaxDynamicRangeRGB(Pix pixs, int type)
      Original signature : PIX* pixMaxDynamicRangeRGB(PIX*, l_int32)
    • linearScaleRGBVal

      int linearScaleRGBVal(int sval, float factor)
      Original signature : l_uint32 linearScaleRGBVal(l_uint32, l_float32)
    • logScaleRGBVal

      int logScaleRGBVal(int sval, FloatBuffer tab, float factor)
      Original signature : l_uint32 logScaleRGBVal(l_uint32, l_float32*, l_float32)
    • pixcompCreateFromString

      PixComp pixcompCreateFromString(ByteBuffer data, NativeSize size, int copyflag)
      Original signature : PIXC* pixcompCreateFromString(l_uint8*, size_t, l_int32)
    • pixcompCopy

      PixComp pixcompCopy(PixComp pixcs)
      Original signature : PIXC* pixcompCopy(PIXC*)
    • pixacompJoin

      int pixacompJoin(PixaComp pixacd, PixaComp pixacs, int istart, int iend)
      Original signature : l_ok pixacompJoin(PIXAC*, PIXAC*, l_int32, l_int32)
    • pixacompInterleave

      PixaComp pixacompInterleave(PixaComp pixac1, PixaComp pixac2)
      Original signature : PIXAC* pixacompInterleave(PIXAC*, PIXAC*)
    • pixacompReadMem

      PixaComp pixacompReadMem(ByteBuffer data, NativeSize size)
      Original signature : PIXAC* pixacompReadMem(const l_uint8*, size_t)
    • pixacompWriteMem

      int pixacompWriteMem(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, PixaComp pixac)
      Original signature : l_ok pixacompWriteMem(l_uint8**, size_t*, PIXAC*)
    • pixThreshold8

      Pix pixThreshold8(Pix pixs, int d, int nlevels, int cmapflag)
      Original signature : PIX* pixThreshold8(PIX*, l_int32, l_int32, l_int32)
    • pixRemoveColormapGeneral

      Pix pixRemoveColormapGeneral(Pix pixs, int type, int ifnocmap)
      Original signature : PIX* pixRemoveColormapGeneral(PIX*, l_int32, l_int32)
    • pixRemoveColormap

      Pix pixRemoveColormap(Pix pixs, int type)
      Original signature : PIX* pixRemoveColormap(PIX*, l_int32)
    • pixAddGrayColormap8

      int pixAddGrayColormap8(Pix pixs)
      Original signature : l_ok pixAddGrayColormap8(PIX*)
    • pixAddMinimalGrayColormap8

      Pix pixAddMinimalGrayColormap8(Pix pixs)
      Original signature : PIX* pixAddMinimalGrayColormap8(PIX*)
    • pixConvertRGBToLuminance

      Pix pixConvertRGBToLuminance(Pix pixs)
      Original signature : PIX* pixConvertRGBToLuminance(PIX*)
    • pixConvertRGBToGray

      Pix pixConvertRGBToGray(Pix pixs, float rwt, float gwt, float bwt)
      Original signature : PIX* pixConvertRGBToGray(PIX*, l_float32, l_float32, l_float32)
    • pixConvertRGBToGrayFast

      Pix pixConvertRGBToGrayFast(Pix pixs)
      Original signature : PIX* pixConvertRGBToGrayFast(PIX*)
    • pixConvertRGBToGrayMinMax

      Pix pixConvertRGBToGrayMinMax(Pix pixs, int type)
      Original signature : PIX* pixConvertRGBToGrayMinMax(PIX*, l_int32)
    • pixConvertRGBToGraySatBoost

      Pix pixConvertRGBToGraySatBoost(Pix pixs, int refval)
      Original signature : PIX* pixConvertRGBToGraySatBoost(PIX*, l_int32)
    • pixConvertRGBToGrayArb

      Pix pixConvertRGBToGrayArb(Pix pixs, float rc, float gc, float bc)
      Original signature : PIX* pixConvertRGBToGrayArb(PIX*, l_float32, l_float32, l_float32)
    • pixConvertRGBToBinaryArb

      Pix pixConvertRGBToBinaryArb(Pix pixs, float rc, float gc, float bc, int thresh, int relation)
      Original signature : PIX* pixConvertRGBToBinaryArb(PIX*, l_float32, l_float32, l_float32, l_int32, l_int32)
    • pixConvertGrayToColormap

      Pix pixConvertGrayToColormap(Pix pixs)
      Original signature : PIX* pixConvertGrayToColormap(PIX*)
    • pixConvertGrayToColormap8

      Pix pixConvertGrayToColormap8(Pix pixs, int mindepth)
      Original signature : PIX* pixConvertGrayToColormap8(PIX*, l_int32)
    • pixColorizeGray

      Pix pixColorizeGray(Pix pixs, int color, int cmapflag)
      Original signature : PIX* pixColorizeGray(PIX*, l_uint32, l_int32)
    • pixConvertRGBToColormap

      Pix pixConvertRGBToColormap(Pix pixs, int ditherflag)
      Original signature : PIX* pixConvertRGBToColormap(PIX*, l_int32)
    • pixConvertCmapTo1

      Pix pixConvertCmapTo1(Pix pixs)
      Original signature : PIX* pixConvertCmapTo1(PIX*)
    • pixQuantizeIfFewColors

      int pixQuantizeIfFewColors(Pix pixs, int maxcolors, int mingraycolors, int octlevel, com.sun.jna.ptr.PointerByReference ppixd)
      Original signature : l_ok pixQuantizeIfFewColors(PIX*, l_int32, l_int32, l_int32, PIX**)
    • pixConvert16To8

      Pix pixConvert16To8(Pix pixs, int type)
      Original signature : PIX* pixConvert16To8(PIX*, l_int32)
    • pixConvertGrayToFalseColor

      Pix pixConvertGrayToFalseColor(Pix pixs, float gamma)
      Original signature : PIX* pixConvertGrayToFalseColor(PIX*, l_float32)
    • pixUnpackBinary

      Pix pixUnpackBinary(Pix pixs, int depth, int invert)
      Original signature : PIX* pixUnpackBinary(PIX*, l_int32, l_int32)
    • pixConvert1To16

      Pix pixConvert1To16(Pix pixd, Pix pixs, short val0, short val1)
      Original signature : PIX* pixConvert1To16(PIX*, PIX*, l_uint16, l_uint16)
    • pixConvert1To32

      Pix pixConvert1To32(Pix pixd, Pix pixs, int val0, int val1)
      Original signature : PIX* pixConvert1To32(PIX*, PIX*, l_uint32, l_uint32)
    • pixConvert1To2Cmap

      Pix pixConvert1To2Cmap(Pix pixs)
      Original signature : PIX* pixConvert1To2Cmap(PIX*)
    • pixConvert1To2

      Pix pixConvert1To2(Pix pixd, Pix pixs, int val0, int val1)
      Original signature : PIX* pixConvert1To2(PIX*, PIX*, l_int32, l_int32)
    • pixConvert1To4Cmap

      Pix pixConvert1To4Cmap(Pix pixs)
      Original signature : PIX* pixConvert1To4Cmap(PIX*)
    • pixConvert1To4

      Pix pixConvert1To4(Pix pixd, Pix pixs, int val0, int val1)
      Original signature : PIX* pixConvert1To4(PIX*, PIX*, l_int32, l_int32)
    • pixConvert1To8Cmap

      Pix pixConvert1To8Cmap(Pix pixs)
      Original signature : PIX* pixConvert1To8Cmap(PIX*)
    • pixConvert1To8

      Pix pixConvert1To8(Pix pixd, Pix pixs, byte val0, byte val1)
      Original signature : PIX* pixConvert1To8(PIX*, PIX*, l_uint8, l_uint8)
    • pixConvert2To8

      Pix pixConvert2To8(Pix pixs, byte val0, byte val1, byte val2, byte val3, int cmapflag)
      Original signature : PIX* pixConvert2To8(PIX*, l_uint8, l_uint8, l_uint8, l_uint8, l_int32)
    • pixConvert4To8

      Pix pixConvert4To8(Pix pixs, int cmapflag)
      Original signature : PIX* pixConvert4To8(PIX*, l_int32)
    • pixConvert8To16

      Pix pixConvert8To16(Pix pixs, int leftshift)
      Original signature : PIX* pixConvert8To16(PIX*, l_int32)
    • pixConvertTo2

      Pix pixConvertTo2(Pix pixs)
      Original signature : PIX* pixConvertTo2(PIX*)
    • pixConvert8To2

      Pix pixConvert8To2(Pix pix)
      Original signature : PIX* pixConvert8To2(PIX*)
    • pixConvertTo4

      Pix pixConvertTo4(Pix pixs)
      Original signature : PIX* pixConvertTo4(PIX*)
    • pixConvert8To4

      Pix pixConvert8To4(Pix pix)
      Original signature : PIX* pixConvert8To4(PIX*)
    • pixConvertTo1

      Pix pixConvertTo1(Pix pixs, int threshold)
      Original signature : PIX* pixConvertTo1(PIX*, l_int32)
    • pixConvertTo1BySampling

      Pix pixConvertTo1BySampling(Pix pixs, int factor, int threshold)
      Original signature : PIX* pixConvertTo1BySampling(PIX*, l_int32, l_int32)
    • pixConvertTo8

      Pix pixConvertTo8(Pix pixs, int cmapflag)
      Original signature : PIX* pixConvertTo8(PIX*, l_int32)
    • pixConvertTo8BySampling

      Pix pixConvertTo8BySampling(Pix pixs, int factor, int cmapflag)
      Original signature : PIX* pixConvertTo8BySampling(PIX*, l_int32, l_int32)
    • pixConvertTo8Colormap

      Pix pixConvertTo8Colormap(Pix pixs, int dither)
      Original signature : PIX* pixConvertTo8Colormap(PIX*, l_int32)
    • pixConvertTo16

      Pix pixConvertTo16(Pix pixs)
      Original signature : PIX* pixConvertTo16(PIX*)
    • pixConvertTo32

      Pix pixConvertTo32(Pix pixs)
      Original signature : PIX* pixConvertTo32(PIX*)
    • pixConvertTo32BySampling

      Pix pixConvertTo32BySampling(Pix pixs, int factor)
      Original signature : PIX* pixConvertTo32BySampling(PIX*, l_int32)
    • pixConvert8To32

      Pix pixConvert8To32(Pix pixs)
      Original signature : PIX* pixConvert8To32(PIX*)
    • pixConvertTo8Or32

      Pix pixConvertTo8Or32(Pix pixs, int copyflag, int warnflag)
      Original signature : PIX* pixConvertTo8Or32(PIX*, l_int32, l_int32)
    • pixConvert24To32

      Pix pixConvert24To32(Pix pixs)
      Original signature : PIX* pixConvert24To32(PIX*)
    • pixConvert32To24

      Pix pixConvert32To24(Pix pixs)
      Original signature : PIX* pixConvert32To24(PIX*)
    • pixConvert32To16

      Pix pixConvert32To16(Pix pixs, int type)
      Original signature : PIX* pixConvert32To16(PIX*, l_int32)
    • pixConvert32To8

      Pix pixConvert32To8(Pix pixs, int type16, int type8)
      Original signature : PIX* pixConvert32To8(PIX*, l_int32, l_int32)
    • pixRemoveAlpha

      Pix pixRemoveAlpha(Pix pixs)
      Original signature : PIX* pixRemoveAlpha(PIX*)
    • pixAddAlphaTo1bpp

      Pix pixAddAlphaTo1bpp(Pix pixd, Pix pixs)
      Original signature : PIX* pixAddAlphaTo1bpp(PIX*, PIX*)
    • pixConvertLossless

      Pix pixConvertLossless(Pix pixs, int d)
      Original signature : PIX* pixConvertLossless(PIX*, l_int32)
    • pixConvertForPSWrap

      Pix pixConvertForPSWrap(Pix pixs)
      Original signature : PIX* pixConvertForPSWrap(PIX*)
    • pixConvertToSubpixelRGB

      Pix pixConvertToSubpixelRGB(Pix pixs, float scalex, float scaley, int order)
      Original signature : PIX* pixConvertToSubpixelRGB(PIX*, l_float32, l_float32, l_int32)
    • pixConvertGrayToSubpixelRGB

      Pix pixConvertGrayToSubpixelRGB(Pix pixs, float scalex, float scaley, int order)
      Original signature : PIX* pixConvertGrayToSubpixelRGB(PIX*, l_float32, l_float32, l_int32)
    • pixConvertColorToSubpixelRGB

      Pix pixConvertColorToSubpixelRGB(Pix pixs, float scalex, float scaley, int order)
      Original signature : PIX* pixConvertColorToSubpixelRGB(PIX*, l_float32, l_float32, l_int32)
    • l_setNeutralBoostVal

      void l_setNeutralBoostVal(int val)
      Original signature : void l_setNeutralBoostVal(l_int32)
    • pixConnCompIncrInit

      int pixConnCompIncrInit(Pix pixs, int conn, com.sun.jna.ptr.PointerByReference ppixd, com.sun.jna.ptr.PointerByReference pptaa, IntBuffer pncc)
      Original signature : l_ok pixConnCompIncrInit(PIX*, l_int32, PIX**, PTAA**, l_int32*)
    • pixConnCompIncrInit

      int pixConnCompIncrInit(Pix pixs, int conn, com.sun.jna.ptr.PointerByReference ppixd, com.sun.jna.ptr.PointerByReference pptaa, com.sun.jna.ptr.IntByReference pncc)
      Original signature : l_ok pixConnCompIncrInit(PIX*, l_int32, PIX**, PTAA**, l_int32*)
    • pixConnCompIncrAdd

      int pixConnCompIncrAdd(Pix pixs, Ptaa ptaa, IntBuffer pncc, float x, float y, int debug)
      Original signature : l_int32 pixConnCompIncrAdd(PIX*, PTAA*, l_int32*, l_float32, l_float32, l_int32)
    • pixGetSortedNeighborValues

      int pixGetSortedNeighborValues(Pix pixs, int x, int y, int conn, com.sun.jna.ptr.PointerByReference pneigh, IntBuffer pnvals)
      Original signature : l_ok pixGetSortedNeighborValues(PIX*, l_int32, l_int32, l_int32, l_int32**, l_int32*)
    • pixReadStreamPng

      Pix pixReadStreamPng(ILeptonica.FILE fp)
      Original signature : PIX* pixReadStreamPng(FILE*)
    • readHeaderPng

      int readHeaderPng(String filename, IntBuffer pw, IntBuffer ph, IntBuffer pbps, IntBuffer pspp, IntBuffer piscmap)
      Original signature : l_ok readHeaderPng(const char*, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*)
    • freadHeaderPng

      int freadHeaderPng(ILeptonica.FILE fp, IntBuffer pw, IntBuffer ph, IntBuffer pbps, IntBuffer pspp, IntBuffer piscmap)
      Original signature : l_ok freadHeaderPng(FILE*, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*)
    • readHeaderMemPng

      int readHeaderMemPng(ByteBuffer data, NativeSize size, IntBuffer pw, IntBuffer ph, IntBuffer pbps, IntBuffer pspp, IntBuffer piscmap)
      Original signature : l_ok readHeaderMemPng(const l_uint8*, size_t, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*)
    • isPngInterlaced

      int isPngInterlaced(String filename, IntBuffer pinterlaced)
      Original signature : l_ok isPngInterlaced(const char*, l_int32*)
    • pixWritePng

      int pixWritePng(String filename, Pix pix, float gamma)
      Original signature : l_ok pixWritePng(const char*, PIX*, l_float32)
    • pixSetZlibCompression

      int pixSetZlibCompression(Pix pix, int compval)
      Original signature : l_ok pixSetZlibCompression(PIX*, l_int32)
    • l_pngSetReadStrip16To8

      void l_pngSetReadStrip16To8(int flag)
      Original signature : void l_pngSetReadStrip16To8(l_int32)
    • pixReadMemPng

      Pix pixReadMemPng(ByteBuffer filedata, NativeSize filesize)
      Original signature : PIX* pixReadMemPng(const l_uint8*, size_t)
    • pixWriteMemPng

      int pixWriteMemPng(com.sun.jna.ptr.PointerByReference pfiledata, NativeSizeByReference pfilesize, Pix pix, float gamma)
      Original signature : l_ok pixWriteMemPng(l_uint8**, size_t*, PIX*, l_float32)
    • pixWriteStreamPam

      int pixWriteStreamPam(ILeptonica.FILE fp, Pix pix)
      Original signature : l_ok pixWriteStreamPam(FILE*, PIX*)
    • pixReadMemPnm

      Pix pixReadMemPnm(ByteBuffer data, NativeSize size)
      Original signature : PIX* pixReadMemPnm(const l_uint8*, size_t)
    • readHeaderMemPnm

      int readHeaderMemPnm(ByteBuffer data, NativeSize size, IntBuffer pw, IntBuffer ph, IntBuffer pd, IntBuffer ptype, IntBuffer pbps, IntBuffer pspp)
      Original signature : l_ok readHeaderMemPnm(const l_uint8*, size_t, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*)
    • pixWriteMemPam

      int pixWriteMemPam(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, Pix pix)
      Original signature : l_ok pixWriteMemPam(l_uint8**, size_t*, PIX*)
    • generateUncompressedPS

      com.sun.jna.Pointer generateUncompressedPS(ByteBuffer hexdata, int w, int h, int d, int psbpl, int bps, float xpt, float ypt, float wpt, float hpt, int boxflag)
      Original signature : char* generateUncompressedPS(char*, l_int32, l_int32, l_int32, l_int32, l_int32, l_float32, l_float32, l_float32, l_float32, l_int32)
    • ptaReadMem

      Pta ptaReadMem(ByteBuffer data, NativeSize size)
      Original signature : PTA* ptaReadMem(const l_uint8*, size_t)
    • ptaWriteMem

      int ptaWriteMem(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, Pta pta, int type)
      Original signature : l_ok ptaWriteMem(l_uint8**, size_t*, PTA*, l_int32)
    • ptaaReadMem

      Ptaa ptaaReadMem(ByteBuffer data, NativeSize size)
      Original signature : PTAA* ptaaReadMem(const l_uint8*, size_t)
    • ptaaWriteMem

      int ptaaWriteMem(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, Ptaa ptaa, int type)
      Original signature : l_ok ptaaWriteMem(l_uint8**, size_t*, PTAA*, l_int32)
    • ptaSelectRange

      Pta ptaSelectRange(Pta ptas, int first, int last)
      Original signature : PTA* ptaSelectRange(PTA*, l_int32, l_int32)
    • ptaGetMinMax

      int ptaGetMinMax(Pta pta, FloatBuffer pxmin, FloatBuffer pymin, FloatBuffer pxmax, FloatBuffer pymax)
      Original signature : l_ok ptaGetMinMax(PTA*, l_float32*, l_float32*, l_float32*, l_float32*)
    • ptaSelectByValue

      Pta ptaSelectByValue(Pta ptas, float xth, float yth, int type, int relation)
      Original signature : PTA* ptaSelectByValue(PTA*, l_float32, l_float32, l_int32, l_int32)
    • ptaCropToMask

      Pta ptaCropToMask(Pta ptas, Pix pixm)
      Original signature : PTA* ptaCropToMask(PTA*, PIX*)
    • pixaReadFiles

      Pixa pixaReadFiles(String dirname, String substr)
      Original signature : PIXA* pixaReadFiles(const char*, const char*)
    • pixaReadFilesSA

      Pixa pixaReadFilesSA(Sarray sa)
      Original signature : PIXA* pixaReadFilesSA(SARRAY*)
    • pixRead

      Pix pixRead(String filename)
      Original signature : PIX* pixRead(const char*)
    • pixReadWithHint

      Pix pixReadWithHint(String filename, int hint)
      Original signature : PIX* pixReadWithHint(const char*, l_int32)
    • pixReadIndexed

      Pix pixReadIndexed(Sarray sa, int index)
      Original signature : PIX* pixReadIndexed(SARRAY*, l_int32)
    • pixReadStream

      Pix pixReadStream(ILeptonica.FILE fp, int hint)
      Original signature : PIX* pixReadStream(FILE*, l_int32)
    • pixReadHeader

      int pixReadHeader(String filename, IntBuffer pformat, IntBuffer pw, IntBuffer ph, IntBuffer pbps, IntBuffer pspp, IntBuffer piscmap)
      Original signature : l_ok pixReadHeader(const char*, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*)
    • findFileFormat

      int findFileFormat(String filename, IntBuffer pformat)
      Original signature : l_ok findFileFormat(const char*, l_int32*)
    • findFileFormatBuffer

      int findFileFormatBuffer(ByteBuffer buf, IntBuffer pformat)
      Original signature : l_ok findFileFormatBuffer(const l_uint8*, l_int32*)
    • fileFormatIsTiff

      int fileFormatIsTiff(ILeptonica.FILE fp)
      Original signature : l_int32 fileFormatIsTiff(FILE*)
    • pixReadMem

      Pix pixReadMem(ByteBuffer data, NativeSize size)
      Original signature : PIX* pixReadMem(const l_uint8*, size_t)
    • pixReadHeaderMem

      int pixReadHeaderMem(ByteBuffer data, NativeSize size, IntBuffer pformat, IntBuffer pw, IntBuffer ph, IntBuffer pbps, IntBuffer pspp, IntBuffer piscmap)
      Original signature : l_ok pixReadHeaderMem(const l_uint8*, size_t, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*)
    • writeImageFileInfo

      int writeImageFileInfo(String filename, ILeptonica.FILE fpout, int headeronly)
      Original signature : l_ok writeImageFileInfo(const char*, FILE*, l_int32)
    • ioFormatTest

      int ioFormatTest(String filename)
      Original signature : l_ok ioFormatTest(const char*)
    • recogCreate

      L_Recog recogCreate(int scalew, int scaleh, int linew, int threshold, int maxyshift)
      Original signature : L_RECOG* recogCreate(l_int32, l_int32, l_int32, l_int32, l_int32)
    • recogSetParams

      int recogSetParams(L_Recog recog, int type, int min_nopad, float max_wh_ratio, float max_ht_ratio)
      Original signature : l_ok recogSetParams(L_RECOG*, l_int32, l_int32, l_float32, l_float32)
    • recogReadMem

      L_Recog recogReadMem(ByteBuffer data, NativeSize size)
      Original signature : L_RECOG* recogReadMem(const l_uint8*, size_t)
    • regTestSetup

      int regTestSetup(int argc, com.sun.jna.ptr.PointerByReference argv, com.sun.jna.ptr.PointerByReference prp)
      Original signature : l_ok regTestSetup(l_int32, char**, L_REGPARAMS**)
    • regTestCleanup

      int regTestCleanup(L_RegParams rp)
      Original signature : l_ok regTestCleanup(L_REGPARAMS*)
    • regTestCompareValues

      int regTestCompareValues(L_RegParams rp, float val1, float val2, float delta)
      Original signature : l_ok regTestCompareValues(L_REGPARAMS*, l_float32, l_float32, l_float32)
    • regTestCompareStrings

      int regTestCompareStrings(L_RegParams rp, ByteBuffer string1, NativeSize bytes1, ByteBuffer string2, NativeSize bytes2)
      Original signature : l_ok regTestCompareStrings(L_REGPARAMS*, l_uint8*, size_t, l_uint8*, size_t)
    • regTestComparePix

      int regTestComparePix(L_RegParams rp, Pix pix1, Pix pix2)
      Original signature : l_ok regTestComparePix(L_REGPARAMS*, PIX*, PIX*)
    • regTestCompareSimilarPix

      int regTestCompareSimilarPix(L_RegParams rp, Pix pix1, Pix pix2, int mindiff, float maxfract, int printstats)
      Original signature : l_ok regTestCompareSimilarPix(L_REGPARAMS*, PIX*, PIX*, l_int32, l_float32, l_int32)
    • regTestCheckFile

      int regTestCheckFile(L_RegParams rp, String localname)
      Original signature : l_ok regTestCheckFile(L_REGPARAMS*, const char*)
    • regTestCompareFiles

      int regTestCompareFiles(L_RegParams rp, int index1, int index2)
      Original signature : l_ok regTestCompareFiles(L_REGPARAMS*, l_int32, l_int32)
    • regTestWritePixAndCheck

      int regTestWritePixAndCheck(L_RegParams rp, Pix pix, int format)
      Original signature : l_ok regTestWritePixAndCheck(L_REGPARAMS*, PIX*, l_int32)
    • regTestGenLocalFilename

      com.sun.jna.Pointer regTestGenLocalFilename(L_RegParams rp, int index, int format)
      Original signature : char* regTestGenLocalFilename(L_REGPARAMS*, l_int32, l_int32)
    • pixRotate

      Pix pixRotate(Pix pixs, float angle, int type, int incolor, int width, int height)
      Original signature : PIX* pixRotate(PIX*, l_float32, l_int32, l_int32, l_int32, l_int32)
    • pixEmbedForRotation

      Pix pixEmbedForRotation(Pix pixs, float angle, int incolor, int width, int height)
      Original signature : PIX* pixEmbedForRotation(PIX*, l_float32, l_int32, l_int32, l_int32)
    • pixRotateBySampling

      Pix pixRotateBySampling(Pix pixs, int xcen, int ycen, float angle, int incolor)
      Original signature : PIX* pixRotateBySampling(PIX*, l_int32, l_int32, l_float32, l_int32)
    • pixRotateBinaryNice

      Pix pixRotateBinaryNice(Pix pixs, float angle, int incolor)
      Original signature : PIX* pixRotateBinaryNice(PIX*, l_float32, l_int32)
    • pixRotateWithAlpha

      Pix pixRotateWithAlpha(Pix pixs, float angle, Pix pixg, float fract)
      Original signature : PIX* pixRotateWithAlpha(PIX*, l_float32, PIX*, l_float32)
    • pixRotateAM

      Pix pixRotateAM(Pix pixs, float angle, int incolor)
      Original signature : PIX* pixRotateAM(PIX*, l_float32, l_int32)
    • pixRotateAMColor

      Pix pixRotateAMColor(Pix pixs, float angle, int colorval)
      Original signature : PIX* pixRotateAMColor(PIX*, l_float32, l_uint32)
    • pixRotateAMGray

      Pix pixRotateAMGray(Pix pixs, float angle, byte grayval)
      Original signature : PIX* pixRotateAMGray(PIX*, l_float32, l_uint8)
    • pixRotateAMCorner

      Pix pixRotateAMCorner(Pix pixs, float angle, int incolor)
      Original signature : PIX* pixRotateAMCorner(PIX*, l_float32, l_int32)
    • pixRotateAMColorCorner

      Pix pixRotateAMColorCorner(Pix pixs, float angle, int fillval)
      Original signature : PIX* pixRotateAMColorCorner(PIX*, l_float32, l_uint32)
    • pixRotateAMGrayCorner

      Pix pixRotateAMGrayCorner(Pix pixs, float angle, byte grayval)
      Original signature : PIX* pixRotateAMGrayCorner(PIX*, l_float32, l_uint8)
    • pixRotateAMColorFast

      Pix pixRotateAMColorFast(Pix pixs, float angle, int colorval)
      Original signature : PIX* pixRotateAMColorFast(PIX*, l_float32, l_uint32)
    • pixRotateOrth

      Pix pixRotateOrth(Pix pixs, int quads)
      Original signature : PIX* pixRotateOrth(PIX*, l_int32)
    • pixRotate180

      Pix pixRotate180(Pix pixd, Pix pixs)
      Original signature : PIX* pixRotate180(PIX*, PIX*)
    • pixRotate90

      Pix pixRotate90(Pix pixs, int direction)
      Original signature : PIX* pixRotate90(PIX*, l_int32)
    • pixFlipLR

      Pix pixFlipLR(Pix pixd, Pix pixs)
      Original signature : PIX* pixFlipLR(PIX*, PIX*)
    • pixFlipTB

      Pix pixFlipTB(Pix pixd, Pix pixs)
      Original signature : PIX* pixFlipTB(PIX*, PIX*)
    • pixRotateShear

      Pix pixRotateShear(Pix pixs, int xcen, int ycen, float angle, int incolor)
      Original signature : PIX* pixRotateShear(PIX*, l_int32, l_int32, l_float32, l_int32)
    • pixRotate2Shear

      Pix pixRotate2Shear(Pix pixs, int xcen, int ycen, float angle, int incolor)
      Original signature : PIX* pixRotate2Shear(PIX*, l_int32, l_int32, l_float32, l_int32)
    • pixRotate3Shear

      Pix pixRotate3Shear(Pix pixs, int xcen, int ycen, float angle, int incolor)
      Original signature : PIX* pixRotate3Shear(PIX*, l_int32, l_int32, l_float32, l_int32)
    • pixRotateShearIP

      int pixRotateShearIP(Pix pixs, int xcen, int ycen, float angle, int incolor)
      Original signature : l_ok pixRotateShearIP(PIX*, l_int32, l_int32, l_float32, l_int32)
    • pixRotateShearCenter

      Pix pixRotateShearCenter(Pix pixs, float angle, int incolor)
      Original signature : PIX* pixRotateShearCenter(PIX*, l_float32, l_int32)
    • pixRotateShearCenterIP

      int pixRotateShearCenterIP(Pix pixs, float angle, int incolor)
      Original signature : l_ok pixRotateShearCenterIP(PIX*, l_float32, l_int32)
    • sarrayCreateInitialized

      Sarray sarrayCreateInitialized(int n, String initstr)
      Original signature : SARRAY* sarrayCreateInitialized(l_int32, const char*)
    • sarrayCreateLinesFromString

      Sarray sarrayCreateLinesFromString(String string, int blankflag)
      Original signature : SARRAY* sarrayCreateLinesFromString(const char*, l_int32)
    • sarrayAddString

      int sarrayAddString(Sarray sa, String string, int copyflag)
      Original signature : l_ok sarrayAddString(SARRAY*, const char*, l_int32)
    • sarrayReplaceString

      int sarrayReplaceString(Sarray sa, int index, ByteBuffer newstr, int copyflag)
      Original signature : l_ok sarrayReplaceString(SARRAY*, l_int32, char*, l_int32)
    • sarrayJoin

      int sarrayJoin(Sarray sa1, Sarray sa2)
      Original signature : l_ok sarrayJoin(SARRAY*, SARRAY*)
    • sarrayPadToSameSize

      int sarrayPadToSameSize(Sarray sa1, Sarray sa2, String padstring)
      Original signature : l_ok sarrayPadToSameSize(SARRAY*, SARRAY*, const char*)
    • sarrayReadMem

      Sarray sarrayReadMem(ByteBuffer data, NativeSize size)
      Original signature : SARRAY* sarrayReadMem(const l_uint8*, size_t)
    • sarrayWriteMem

      int sarrayWriteMem(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, Sarray sa)
      Original signature : l_ok sarrayWriteMem(l_uint8**, size_t*, SARRAY*)
    • sarrayGenerateIntegers

      Sarray sarrayGenerateIntegers(int n)
      Original signature : SARRAY* sarrayGenerateIntegers(l_int32)
    • pixScale

      Pix pixScale(Pix pixs, float scalex, float scaley)
      Original signature : PIX* pixScale(PIX*, l_float32, l_float32)
    • pixScaleToSizeRel

      Pix pixScaleToSizeRel(Pix pixs, int delw, int delh)
      Original signature : PIX* pixScaleToSizeRel(PIX*, l_int32, l_int32)
    • pixScaleToSize

      Pix pixScaleToSize(Pix pixs, int wd, int hd)
      Original signature : PIX* pixScaleToSize(PIX*, l_int32, l_int32)
    • pixScaleGeneral

      Pix pixScaleGeneral(Pix pixs, float scalex, float scaley, float sharpfract, int sharpwidth)
      Original signature : PIX* pixScaleGeneral(PIX*, l_float32, l_float32, l_float32, l_int32)
    • pixScaleLI

      Pix pixScaleLI(Pix pixs, float scalex, float scaley)
      Original signature : PIX* pixScaleLI(PIX*, l_float32, l_float32)
    • pixScaleColorLI

      Pix pixScaleColorLI(Pix pixs, float scalex, float scaley)
      Original signature : PIX* pixScaleColorLI(PIX*, l_float32, l_float32)
    • pixScaleColor2xLI

      Pix pixScaleColor2xLI(Pix pixs)
      Original signature : PIX* pixScaleColor2xLI(PIX*)
    • pixScaleColor4xLI

      Pix pixScaleColor4xLI(Pix pixs)
      Original signature : PIX* pixScaleColor4xLI(PIX*)
    • pixScaleGrayLI

      Pix pixScaleGrayLI(Pix pixs, float scalex, float scaley)
      Original signature : PIX* pixScaleGrayLI(PIX*, l_float32, l_float32)
    • pixScaleGray2xLI

      Pix pixScaleGray2xLI(Pix pixs)
      Original signature : PIX* pixScaleGray2xLI(PIX*)
    • pixScaleGray4xLI

      Pix pixScaleGray4xLI(Pix pixs)
      Original signature : PIX* pixScaleGray4xLI(PIX*)
    • pixScaleBySampling

      Pix pixScaleBySampling(Pix pixs, float scalex, float scaley)
      Original signature : PIX* pixScaleBySampling(PIX*, l_float32, l_float32)
    • pixScaleBySamplingToSize

      Pix pixScaleBySamplingToSize(Pix pixs, int wd, int hd)
      Original signature : PIX* pixScaleBySamplingToSize(PIX*, l_int32, l_int32)
    • pixScaleByIntSampling

      Pix pixScaleByIntSampling(Pix pixs, int factor)
      Original signature : PIX* pixScaleByIntSampling(PIX*, l_int32)
    • pixScaleRGBToGrayFast

      Pix pixScaleRGBToGrayFast(Pix pixs, int factor, int color)
      Original signature : PIX* pixScaleRGBToGrayFast(PIX*, l_int32, l_int32)
    • pixScaleRGBToBinaryFast

      Pix pixScaleRGBToBinaryFast(Pix pixs, int factor, int thresh)
      Original signature : PIX* pixScaleRGBToBinaryFast(PIX*, l_int32, l_int32)
    • pixScaleGrayToBinaryFast

      Pix pixScaleGrayToBinaryFast(Pix pixs, int factor, int thresh)
      Original signature : PIX* pixScaleGrayToBinaryFast(PIX*, l_int32, l_int32)
    • pixScaleSmooth

      Pix pixScaleSmooth(Pix pix, float scalex, float scaley)
      Original signature : PIX* pixScaleSmooth(PIX*, l_float32, l_float32)
    • pixScaleSmoothToSize

      Pix pixScaleSmoothToSize(Pix pixs, int wd, int hd)
      Original signature : PIX* pixScaleSmoothToSize(PIX*, l_int32, l_int32)
    • pixScaleRGBToGray2

      Pix pixScaleRGBToGray2(Pix pixs, float rwt, float gwt, float bwt)
      Original signature : PIX* pixScaleRGBToGray2(PIX*, l_float32, l_float32, l_float32)
    • pixScaleAreaMap

      Pix pixScaleAreaMap(Pix pix, float scalex, float scaley)
      Original signature : PIX* pixScaleAreaMap(PIX*, l_float32, l_float32)
    • pixScaleAreaMap2

      Pix pixScaleAreaMap2(Pix pix)
      Original signature : PIX* pixScaleAreaMap2(PIX*)
    • pixScaleBinary

      Pix pixScaleBinary(Pix pixs, float scalex, float scaley)
      Original signature : PIX* pixScaleBinary(PIX*, l_float32, l_float32)
    • pixScaleToGray

      Pix pixScaleToGray(Pix pixs, float scalefactor)
      Original signature : PIX* pixScaleToGray(PIX*, l_float32)
    • pixScaleToGrayFast

      Pix pixScaleToGrayFast(Pix pixs, float scalefactor)
      Original signature : PIX* pixScaleToGrayFast(PIX*, l_float32)
    • pixScaleToGray2

      Pix pixScaleToGray2(Pix pixs)
      Original signature : PIX* pixScaleToGray2(PIX*)
    • pixScaleToGray3

      Pix pixScaleToGray3(Pix pixs)
      Original signature : PIX* pixScaleToGray3(PIX*)
    • pixScaleToGray4

      Pix pixScaleToGray4(Pix pixs)
      Original signature : PIX* pixScaleToGray4(PIX*)
    • pixScaleToGray6

      Pix pixScaleToGray6(Pix pixs)
      Original signature : PIX* pixScaleToGray6(PIX*)
    • pixScaleToGray8

      Pix pixScaleToGray8(Pix pixs)
      Original signature : PIX* pixScaleToGray8(PIX*)
    • pixScaleToGray16

      Pix pixScaleToGray16(Pix pixs)
      Original signature : PIX* pixScaleToGray16(PIX*)
    • pixScaleToGrayMipmap

      Pix pixScaleToGrayMipmap(Pix pixs, float scalefactor)
      Original signature : PIX* pixScaleToGrayMipmap(PIX*, l_float32)
    • pixScaleMipmap

      Pix pixScaleMipmap(Pix pixs1, Pix pixs2, float scale)
      Original signature : PIX* pixScaleMipmap(PIX*, PIX*, l_float32)
    • pixExpandReplicate

      Pix pixExpandReplicate(Pix pixs, int factor)
      Original signature : PIX* pixExpandReplicate(PIX*, l_int32)
    • pixScaleGray2xLIThresh

      Pix pixScaleGray2xLIThresh(Pix pixs, int thresh)
      Original signature : PIX* pixScaleGray2xLIThresh(PIX*, l_int32)
    • pixScaleGray2xLIDither

      Pix pixScaleGray2xLIDither(Pix pixs)
      Original signature : PIX* pixScaleGray2xLIDither(PIX*)
    • pixScaleGray4xLIThresh

      Pix pixScaleGray4xLIThresh(Pix pixs, int thresh)
      Original signature : PIX* pixScaleGray4xLIThresh(PIX*, l_int32)
    • pixScaleGray4xLIDither

      Pix pixScaleGray4xLIDither(Pix pixs)
      Original signature : PIX* pixScaleGray4xLIDither(PIX*)
    • pixScaleGrayMinMax

      Pix pixScaleGrayMinMax(Pix pixs, int xfact, int yfact, int type)
      Original signature : PIX* pixScaleGrayMinMax(PIX*, l_int32, l_int32, l_int32)
    • pixScaleGrayMinMax2

      Pix pixScaleGrayMinMax2(Pix pixs, int type)
      Original signature : PIX* pixScaleGrayMinMax2(PIX*, l_int32)
    • pixScaleGrayRankCascade

      Pix pixScaleGrayRankCascade(Pix pixs, int level1, int level2, int level3, int level4)
      Original signature : PIX* pixScaleGrayRankCascade(PIX*, l_int32, l_int32, l_int32, l_int32)
    • pixScaleGrayRank2

      Pix pixScaleGrayRank2(Pix pixs, int rank)
      Original signature : PIX* pixScaleGrayRank2(PIX*, l_int32)
    • pixScaleAndTransferAlpha

      int pixScaleAndTransferAlpha(Pix pixd, Pix pixs, float scalex, float scaley)
      Original signature : l_ok pixScaleAndTransferAlpha(PIX*, PIX*, l_float32, l_float32)
    • pixScaleWithAlpha

      Pix pixScaleWithAlpha(Pix pixs, float scalex, float scaley, Pix pixg, float fract)
      Original signature : PIX* pixScaleWithAlpha(PIX*, l_float32, l_float32, PIX*, l_float32)
    • selCreate

      Sel selCreate(int height, int width, String name)
      Original signature : SEL* selCreate(l_int32, l_int32, const char*)
    • selDestroy

      void selDestroy(com.sun.jna.ptr.PointerByReference psel)
      Original signature : void selDestroy(SEL**)
    • selCopy

      Sel selCopy(com.sun.jna.Pointer sel)
      Original signature : SEL* selCopy(SEL*)
    • selCreateBrick

      Sel selCreateBrick(int h, int w, int cy, int cx, int type)
      Original signature : SEL* selCreateBrick(l_int32, l_int32, l_int32, l_int32, l_int32)
    • selCreateFromString

      Sel selCreateFromString(String text, int h, int w, String name)
      Original signature : SEL* selCreateFromString(const char*, l_int32, l_int32, const char*)
    • sela4ccThin

      Sela sela4ccThin(Sela sela)
      Original signature : SELA* sela4ccThin(SELA*)
    • sela8ccThin

      Sela sela8ccThin(Sela sela)
      Original signature : SELA* sela8ccThin(SELA*)
    • sela4and8ccThin

      Sela sela4and8ccThin(Sela sela)
      Original signature : SELA* sela4and8ccThin(SELA*)
    • pixDeskewBoth

      Pix pixDeskewBoth(Pix pixs, int redsearch)
      Original signature : PIX* pixDeskewBoth(PIX*, l_int32)
    • pixDeskew

      Pix pixDeskew(Pix pixs, int redsearch)
      Original signature : PIX* pixDeskew(PIX*, l_int32)
    • pixFindSkewAndDeskew

      Pix pixFindSkewAndDeskew(Pix pixs, int redsearch, FloatBuffer pangle, FloatBuffer pconf)
      Original signature : PIX* pixFindSkewAndDeskew(PIX*, l_int32, l_float32*, l_float32*)
    • pixDeskewGeneral

      Pix pixDeskewGeneral(Pix pixs, int redsweep, float sweeprange, float sweepdelta, int redsearch, int thresh, FloatBuffer pangle, FloatBuffer pconf)
      Original signature : PIX* pixDeskewGeneral(PIX*, l_int32, l_float32, l_float32, l_int32, l_int32, l_float32*, l_float32*)
    • pixFindSkew

      int pixFindSkew(Pix pixs, FloatBuffer pangle, FloatBuffer pconf)
      Original signature : l_ok pixFindSkew(PIX*, l_float32*, l_float32*)
    • pixFindSkewSweep

      int pixFindSkewSweep(Pix pixs, FloatBuffer pangle, int reduction, float sweeprange, float sweepdelta)
      Original signature : l_ok pixFindSkewSweep(PIX*, l_float32*, l_int32, l_float32, l_float32)
    • pixFindSkewSweepAndSearch

      int pixFindSkewSweepAndSearch(Pix pixs, FloatBuffer pangle, FloatBuffer pconf, int redsweep, int redsearch, float sweeprange, float sweepdelta, float minbsdelta)
      Original signature : l_ok pixFindSkewSweepAndSearch(PIX*, l_float32*, l_float32*, l_int32, l_int32, l_float32, l_float32, l_float32)
    • pixFindSkewSweepAndSearchScore

      int pixFindSkewSweepAndSearchScore(Pix pixs, FloatBuffer pangle, FloatBuffer pconf, FloatBuffer pendscore, int redsweep, int redsearch, float sweepcenter, float sweeprange, float sweepdelta, float minbsdelta)
      Original signature : l_ok pixFindSkewSweepAndSearchScore(PIX*, l_float32*, l_float32*, l_float32*, l_int32, l_int32, l_float32, l_float32, l_float32, l_float32)
    • pixFindSkewSweepAndSearchScorePivot

      int pixFindSkewSweepAndSearchScorePivot(Pix pixs, FloatBuffer pangle, FloatBuffer pconf, FloatBuffer pendscore, int redsweep, int redsearch, float sweepcenter, float sweeprange, float sweepdelta, float minbsdelta, int pivot)
      Original signature : l_ok pixFindSkewSweepAndSearchScorePivot(PIX*, l_float32*, l_float32*, l_float32*, l_int32, l_int32, l_float32, l_float32, l_float32, l_float32, l_int32)
    • pixFindSkewOrthogonalRange

      int pixFindSkewOrthogonalRange(Pix pixs, FloatBuffer pangle, FloatBuffer pconf, int redsweep, int redsearch, float sweeprange, float sweepdelta, float minbsdelta, float confprior)
      Original signature : l_ok pixFindSkewOrthogonalRange(PIX*, l_float32*, l_float32*, l_int32, l_int32, l_float32, l_float32, l_float32, l_float32)
    • pixFindDifferentialSquareSum

      int pixFindDifferentialSquareSum(Pix pixs, FloatBuffer psum)
      Original signature : l_ok pixFindDifferentialSquareSum(PIX*, l_float32*)
    • pixFindNormalizedSquareSum

      int pixFindNormalizedSquareSum(Pix pixs, FloatBuffer phratio, FloatBuffer pvratio, FloatBuffer pfract)
      Original signature : l_ok pixFindNormalizedSquareSum(PIX*, l_float32*, l_float32*, l_float32*)
    • pixReadMemSpix

      Pix pixReadMemSpix(ByteBuffer data, NativeSize size)
      Original signature : PIX* pixReadMemSpix(const l_uint8*, size_t)
    • strcodeFinalize

      int strcodeFinalize(com.sun.jna.ptr.PointerByReference pstrcode, com.sun.jna.Pointer outdir)
      Original signature : l_int32 strcodeFinalize(L_STRCODE**, const char*)
    • l_getStructStrFromFile

      int l_getStructStrFromFile(String filename, int field, com.sun.jna.ptr.PointerByReference pstr)
      Original signature : l_int32 l_getStructStrFromFile(const char*, l_int32, char**)
    • pixFindStrokeLength

      int pixFindStrokeLength(Pix pixs, IntBuffer tab8, IntBuffer plength)
      Original signature : l_ok pixFindStrokeLength(PIX*, l_int32*, l_int32*)
    • pixFindStrokeWidth

      int pixFindStrokeWidth(Pix pixs, float thresh, IntBuffer tab8, FloatBuffer pwidth, com.sun.jna.ptr.PointerByReference pnahisto)
      Original signature : l_ok pixFindStrokeWidth(PIX*, l_float32, l_int32*, l_float32*, NUMA**)
    • pixFindStrokeWidth

      int pixFindStrokeWidth(Pix pixs, float thresh, com.sun.jna.ptr.IntByReference tab8, com.sun.jna.ptr.FloatByReference pwidth, com.sun.jna.ptr.PointerByReference pnahisto)
      Original signature : l_ok pixFindStrokeWidth(PIX*, l_float32, l_int32*, l_float32*, NUMA**)
    • pixaFindStrokeWidth

      Numa pixaFindStrokeWidth(Pixa pixa, float thresh, IntBuffer tab8, int debug)
      Original signature : NUMA* pixaFindStrokeWidth(PIXA*, l_float32, l_int32*, l_int32)
    • pixaModifyStrokeWidth

      Pixa pixaModifyStrokeWidth(Pixa pixas, float targetw)
      Original signature : PIXA* pixaModifyStrokeWidth(PIXA*, l_float32)
    • pixModifyStrokeWidth

      Pix pixModifyStrokeWidth(Pix pixs, float width, float targetw)
      Original signature : PIX* pixModifyStrokeWidth(PIX*, l_float32, l_float32)
    • pixaSetStrokeWidth

      Pixa pixaSetStrokeWidth(Pixa pixas, int width, int thinfirst, int connectivity)
      Original signature : PIXA* pixaSetStrokeWidth(PIXA*, l_int32, l_int32, l_int32)
    • pixSetStrokeWidth

      Pix pixSetStrokeWidth(Pix pixs, int width, int thinfirst, int connectivity)
      Original signature : PIX* pixSetStrokeWidth(PIX*, l_int32, l_int32, l_int32)
    • pixAddTextlines

      Pix pixAddTextlines(Pix pixs, L_Bmf bmf, String textstr, int val, int location)
      Original signature : PIX* pixAddTextlines(PIX*, L_BMF*, const char*, l_uint32, l_int32)
    • pixaAddTextlines

      Pixa pixaAddTextlines(Pixa pixas, L_Bmf bmf, Sarray sa, int val, int location)
      Original signature : PIXA* pixaAddTextlines(PIXA*, L_BMF*, SARRAY*, l_uint32, l_int32)
    • pixaAddPixWithText

      int pixaAddPixWithText(Pixa pixa, Pix pixs, int reduction, L_Bmf bmf, String textstr, int val, int location)
      Original signature : l_ok pixaAddPixWithText(PIXA*, PIX*, l_int32, L_BMF*, const char*, l_uint32, l_int32)
    • splitStringToParagraphs

      Sarray splitStringToParagraphs(ByteBuffer textstr, int splitflag)
      Original signature : SARRAY* splitStringToParagraphs(char*, l_int32)
    • pixReadTiff

      Pix pixReadTiff(String filename, int n)
      Original signature : PIX* pixReadTiff(const char*, l_int32)
    • pixReadStreamTiff

      Pix pixReadStreamTiff(ILeptonica.FILE fp, int n)
      Original signature : PIX* pixReadStreamTiff(FILE*, l_int32)
    • pixWriteTiff

      int pixWriteTiff(String filename, Pix pix, int comptype, String modestr)
      Original signature : l_ok pixWriteTiff(const char*, PIX*, l_int32, const char*)
    • pixWriteTiffCustom

      int pixWriteTiffCustom(String filename, Pix pix, int comptype, String modestr, Numa natags, Sarray savals, Sarray satypes, Numa nasizes)
      Original signature : l_ok pixWriteTiffCustom(const char*, PIX*, l_int32, const char*, NUMA*, SARRAY*, SARRAY*, NUMA*)
    • pixWriteStreamTiff

      int pixWriteStreamTiff(ILeptonica.FILE fp, Pix pix, int comptype)
      Original signature : l_ok pixWriteStreamTiff(FILE*, PIX*, l_int32)
    • pixWriteStreamTiffWA

      int pixWriteStreamTiffWA(ILeptonica.FILE fp, Pix pix, int comptype, String modestr)
      Original signature : l_ok pixWriteStreamTiffWA(FILE*, PIX*, l_int32, const char*)
    • pixReadFromMultipageTiff

      Pix pixReadFromMultipageTiff(String fname, NativeSizeByReference poffset)
      Original signature : PIX* pixReadFromMultipageTiff(const char*, size_t*)
    • pixaReadMultipageTiff

      Pixa pixaReadMultipageTiff(String filename)
      Original signature : PIXA* pixaReadMultipageTiff(const char*)
    • pixaWriteMultipageTiff

      int pixaWriteMultipageTiff(String fname, Pixa pixa)
      Original signature : l_ok pixaWriteMultipageTiff(const char*, PIXA*)
    • writeMultipageTiff

      int writeMultipageTiff(String dirin, String substr, String fileout)
      Original signature : l_ok writeMultipageTiff(const char*, const char*, const char*)
    • writeMultipageTiffSA

      int writeMultipageTiffSA(Sarray sa, String fileout)
      Original signature : l_ok writeMultipageTiffSA(SARRAY*, const char*)
    • fprintTiffInfo

      int fprintTiffInfo(ILeptonica.FILE fpout, String tiffile)
      Original signature : l_ok fprintTiffInfo(FILE*, const char*)
    • tiffGetCount

      int tiffGetCount(ILeptonica.FILE fp, IntBuffer pn)
      Original signature : l_ok tiffGetCount(FILE*, l_int32*)
    • getTiffResolution

      int getTiffResolution(ILeptonica.FILE fp, IntBuffer pxres, IntBuffer pyres)
      Original signature : l_ok getTiffResolution(FILE*, l_int32*, l_int32*)
    • readHeaderTiff

      int readHeaderTiff(String filename, int n, IntBuffer pw, IntBuffer ph, IntBuffer pbps, IntBuffer pspp, IntBuffer pres, IntBuffer pcmap, IntBuffer pformat)
      Original signature : l_ok readHeaderTiff(const char*, l_int32, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*)
    • freadHeaderTiff

      int freadHeaderTiff(ILeptonica.FILE fp, int n, IntBuffer pw, IntBuffer ph, IntBuffer pbps, IntBuffer pspp, IntBuffer pres, IntBuffer pcmap, IntBuffer pformat)
      Original signature : l_ok freadHeaderTiff(FILE*, l_int32, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*)
    • readHeaderMemTiff

      int readHeaderMemTiff(ByteBuffer cdata, NativeSize size, int n, IntBuffer pw, IntBuffer ph, IntBuffer pbps, IntBuffer pspp, IntBuffer pres, IntBuffer pcmap, IntBuffer pformat)
      Original signature : l_ok readHeaderMemTiff(const l_uint8*, size_t, l_int32, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*, l_int32*)
    • findTiffCompression

      int findTiffCompression(ILeptonica.FILE fp, IntBuffer pcomptype)
      Original signature : l_ok findTiffCompression(FILE*, l_int32*)
    • pixReadMemTiff

      Pix pixReadMemTiff(ByteBuffer cdata, NativeSize size, int n)
      Original signature : PIX* pixReadMemTiff(const l_uint8*, size_t, l_int32)
    • pixReadMemFromMultipageTiff

      Pix pixReadMemFromMultipageTiff(ByteBuffer cdata, NativeSize size, NativeSizeByReference poffset)
      Original signature : PIX* pixReadMemFromMultipageTiff(const l_uint8*, size_t, size_t*)
    • pixaReadMemMultipageTiff

      Pixa pixaReadMemMultipageTiff(ByteBuffer data, NativeSize size)
      Original signature : PIXA* pixaReadMemMultipageTiff(const l_uint8*, size_t)
    • pixaWriteMemMultipageTiff

      int pixaWriteMemMultipageTiff(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, Pixa pixa)
      Original signature : l_ok pixaWriteMemMultipageTiff(l_uint8**, size_t*, PIXA*)
    • pixWriteMemTiff

      int pixWriteMemTiff(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, Pix pix, int comptype)
      Original signature : l_ok pixWriteMemTiff(l_uint8**, size_t*, PIX*, l_int32)
    • pixWriteMemTiffCustom

      int pixWriteMemTiffCustom(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, Pix pix, int comptype, Numa natags, Sarray savals, Sarray satypes, Numa nasizes)
      Original signature : l_ok pixWriteMemTiffCustom(l_uint8**, size_t*, PIX*, l_int32, NUMA*, SARRAY*, SARRAY*, NUMA*)
    • leptSetStderrHandler

      void leptSetStderrHandler(ILeptonica.leptSetStderrHandler_handler_callback handler)
      Original signature : void leptSetStderrHandler(leptSetStderrHandler_handler_callback*)
    • lept_stderr

      void lept_stderr(String fmt, com.sun.jna.ptr.PointerByReference varArgs1)
      Original signature : void lept_stderr(const char*, null)
    • fileReplaceBytes

      int fileReplaceBytes(String filein, int start, int nbytes, ByteBuffer newdata, NativeSize newsize, String fileout)
      Original signature : l_ok fileReplaceBytes(const char*, l_int32, l_int32, l_uint8*, size_t, const char*)
    • genRandomIntOnInterval

      int genRandomIntOnInterval(int start, int end, int seed, IntBuffer pval)
      Original signature : l_ok genRandomIntOnInterval(l_int32, l_int32, l_int32, l_int32*)
    • getLeptonicaVersion

      com.sun.jna.Pointer getLeptonicaVersion()
      Original signature : char* getLeptonicaVersion()
    • l_getCurrentTime

      void l_getCurrentTime(IntBuffer sec, IntBuffer usec)
      Original signature : void l_getCurrentTime(l_int32*, l_int32*)
    • startWallTimer

      L_WallTimer startWallTimer()
      Original signature : L_WALLTIMER* startWallTimer()
    • stopWallTimer

      float stopWallTimer(com.sun.jna.ptr.PointerByReference ptimer)
      Original signature : l_float32 stopWallTimer(L_WALLTIMER**)
    • l_getFormattedDate

      com.sun.jna.Pointer l_getFormattedDate()
      Original signature : char* l_getFormattedDate()
    • arrayReplaceEachSequence

      com.sun.jna.Pointer arrayReplaceEachSequence(ByteBuffer datas, NativeSize dataslen, ByteBuffer seq, NativeSize seqlen, ByteBuffer newseq, NativeSize newseqlen, NativeSizeByReference pdatadlen, IntBuffer pcount)
      Original signature : l_uint8* arrayReplaceEachSequence(const l_uint8*, size_t, const l_uint8*, size_t, const l_uint8*, size_t, size_t*, l_int32*)
    • arrayFindEachSequence

      L_Dna arrayFindEachSequence(ByteBuffer data, NativeSize datalen, ByteBuffer sequence, NativeSize seqlen)
      Original signature : L_DNA* arrayFindEachSequence(const l_uint8*, size_t, const l_uint8*, size_t)
    • arrayFindSequence

      int arrayFindSequence(ByteBuffer data, NativeSize datalen, ByteBuffer sequence, NativeSize seqlen, IntBuffer poffset, IntBuffer pfound)
      Original signature : l_ok arrayFindSequence(const l_uint8*, size_t, const l_uint8*, size_t, l_int32*, l_int32*)
    • reallocNew

      com.sun.jna.Pointer reallocNew(com.sun.jna.ptr.PointerByReference pindata, NativeSize oldsize, NativeSize newsize)
      Original signature : void* reallocNew(void**, size_t, size_t)
    • l_binaryCopy

      com.sun.jna.Pointer l_binaryCopy(ByteBuffer datas, NativeSize size)
      Original signature : l_uint8* l_binaryCopy(l_uint8*, size_t)
    • l_binaryCompare

      int l_binaryCompare(ByteBuffer data1, NativeSize size1, ByteBuffer data2, NativeSize size2, IntBuffer psame)
      Original signature : l_ok l_binaryCompare(const l_uint8*, size_t, const l_uint8*, size_t, l_int32*)
    • lept_free

      void lept_free(com.sun.jna.Pointer ptr)
      Original signature : void lept_free(void*)
    • lept_mkdir

      int lept_mkdir(String subdir)
      Original signature : l_int32 lept_mkdir(const char*)
    • lept_rmdir

      int lept_rmdir(String subdir)
      Original signature : l_int32 lept_rmdir(const char*)
    • lept_direxists

      void lept_direxists(String dir, IntBuffer pexists)
      Original signature : void lept_direxists(const char*, l_int32*)
    • lept_rm

      int lept_rm(String subdir, String tail)
      Original signature : l_int32 lept_rm(const char*, const char*)
    • lept_rmfile

      int lept_rmfile(String filepath)
      Original signature : l_int32 lept_rmfile(const char*)
    • lept_mv

      int lept_mv(String srcfile, String newdir, String newtail, com.sun.jna.ptr.PointerByReference pnewpath)
      Original signature : l_int32 lept_mv(const char*, const char*, const char*, char**)
    • callSystemDebug

      void callSystemDebug(String cmd)
      Original signature : void callSystemDebug(const char*)
    • splitPathAtDirectory

      int splitPathAtDirectory(String pathname, com.sun.jna.ptr.PointerByReference pdir, com.sun.jna.ptr.PointerByReference ptail)
      Original signature : l_ok splitPathAtDirectory(const char*, char**, char**)
    • splitPathAtExtension

      int splitPathAtExtension(String pathname, com.sun.jna.ptr.PointerByReference pbasename, com.sun.jna.ptr.PointerByReference pextension)
      Original signature : l_ok splitPathAtExtension(const char*, char**, char**)
    • pathJoin

      com.sun.jna.Pointer pathJoin(String dir, String fname)
      Original signature : char* pathJoin(const char*, const char*)
    • appendSubdirs

      com.sun.jna.Pointer appendSubdirs(String basedir, String subdirs)
      Original signature : char* appendSubdirs(const char*, const char*)
    • convertSepCharsInPath

      int convertSepCharsInPath(ByteBuffer path, int type)
      Original signature : l_ok convertSepCharsInPath(char*, l_int32)
    • genPathname

      com.sun.jna.Pointer genPathname(String dir, String fname)
      Original signature : char* genPathname(const char*, const char*)
    • makeTempDirname

      int makeTempDirname(ByteBuffer result, NativeSize nbytes, String subdir)
      Original signature : l_ok makeTempDirname(char*, size_t, const char*)
    • modifyTrailingSlash

      int modifyTrailingSlash(ByteBuffer path, NativeSize nbytes, int flag)
      Original signature : l_ok modifyTrailingSlash(char*, size_t, l_int32)
    • l_makeTempFilename

      com.sun.jna.Pointer l_makeTempFilename()
      Original signature : char* l_makeTempFilename()
    • pixSimpleCaptcha

      Pix pixSimpleCaptcha(Pix pixs, int border, int nterms, int seed, int color, int cmapflag)
      Original signature : PIX* pixSimpleCaptcha(PIX*, l_int32, l_int32, l_uint32, l_uint32, l_int32)
    • pixRandomHarmonicWarp

      Pix pixRandomHarmonicWarp(Pix pixs, float xmag, float ymag, float xfreq, float yfreq, int nx, int ny, int seed, int grayval)
      Original signature : PIX* pixRandomHarmonicWarp(PIX*, l_float32, l_float32, l_float32, l_float32, l_int32, l_int32, l_uint32, l_int32)
    • pixWarpStereoscopic

      Pix pixWarpStereoscopic(Pix pixs, int zbend, int zshiftt, int zshiftb, int ybendt, int ybendb, int redleft)
      Original signature : PIX* pixWarpStereoscopic(PIX*, l_int32, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixStretchHorizontal

      Pix pixStretchHorizontal(Pix pixs, int dir, int type, int hmax, int operation, int incolor)
      Original signature : PIX* pixStretchHorizontal(PIX*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixStretchHorizontalSampled

      Pix pixStretchHorizontalSampled(Pix pixs, int dir, int type, int hmax, int incolor)
      Original signature : PIX* pixStretchHorizontalSampled(PIX*, l_int32, l_int32, l_int32, l_int32)
    • pixStretchHorizontalLI

      Pix pixStretchHorizontalLI(Pix pixs, int dir, int type, int hmax, int incolor)
      Original signature : PIX* pixStretchHorizontalLI(PIX*, l_int32, l_int32, l_int32, l_int32)
    • pixQuadraticVShear

      Pix pixQuadraticVShear(Pix pixs, int dir, int vmaxt, int vmaxb, int operation, int incolor)
      Original signature : PIX* pixQuadraticVShear(PIX*, l_int32, l_int32, l_int32, l_int32, l_int32)
    • pixQuadraticVShearSampled

      Pix pixQuadraticVShearSampled(Pix pixs, int dir, int vmaxt, int vmaxb, int incolor)
      Original signature : PIX* pixQuadraticVShearSampled(PIX*, l_int32, l_int32, l_int32, l_int32)
    • pixQuadraticVShearLI

      Pix pixQuadraticVShearLI(Pix pixs, int dir, int vmaxt, int vmaxb, int incolor)
      Original signature : PIX* pixQuadraticVShearLI(PIX*, l_int32, l_int32, l_int32, l_int32)
    • pixStereoFromPair

      Pix pixStereoFromPair(Pix pix1, Pix pix2, float rwt, float gwt, float bwt)
      Original signature : PIX* pixStereoFromPair(PIX*, PIX*, l_float32, l_float32, l_float32)
    • wshedCreate

      L_WShed wshedCreate(Pix pixs, Pix pixm, int mindepth, int debugflag)
      Original signature : L_WSHED* wshedCreate(PIX*, PIX*, l_int32, l_int32)
    • wshedDestroy

      void wshedDestroy(com.sun.jna.ptr.PointerByReference pwshed)
      Original signature : void wshedDestroy(L_WSHED**)
    • wshedApply

      int wshedApply(L_WShed wshed)
      Original signature : l_ok wshedApply(L_WSHED*)
    • wshedBasins

      int wshedBasins(L_WShed wshed, com.sun.jna.ptr.PointerByReference ppixa, com.sun.jna.ptr.PointerByReference pnalevels)
      Original signature : l_ok wshedBasins(L_WSHED*, PIXA**, NUMA**)
    • wshedRenderFill

      Pix wshedRenderFill(L_WShed wshed)
      Original signature : PIX* wshedRenderFill(L_WSHED*)
    • wshedRenderColors

      Pix wshedRenderColors(L_WShed wshed)
      Original signature : PIX* wshedRenderColors(L_WSHED*)
    • pixReadMemWebP

      Pix pixReadMemWebP(ByteBuffer filedata, NativeSize filesize)
      Original signature : PIX* pixReadMemWebP(const l_uint8*, size_t)
    • readHeaderWebP

      int readHeaderWebP(String filename, IntBuffer pw, IntBuffer ph, IntBuffer pspp)
      Original signature : l_ok readHeaderWebP(const char*, l_int32*, l_int32*, l_int32*)
    • readHeaderMemWebP

      int readHeaderMemWebP(ByteBuffer data, NativeSize size, IntBuffer pw, IntBuffer ph, IntBuffer pspp)
      Original signature : l_ok readHeaderMemWebP(const l_uint8*, size_t, l_int32*, l_int32*, l_int32*)
    • pixWriteWebP

      int pixWriteWebP(String filename, Pix pixs, int quality, int lossless)
      Original signature : l_ok pixWriteWebP(const char*, PIX*, l_int32, l_int32)
    • pixWriteMemWebP

      int pixWriteMemWebP(com.sun.jna.ptr.PointerByReference pencdata, NativeSizeByReference pencsize, Pix pixs, int quality, int lossless)
      Original signature : l_ok pixWriteMemWebP(l_uint8**, size_t*, PIX*, l_int32, l_int32)
    • setLeptDebugOK

      void setLeptDebugOK(int allow)
      Original signature : void setLeptDebugOK(l_int32)
    • pixaWriteFiles

      int pixaWriteFiles(String rootname, Pixa pixa, int format)
      Original signature : l_ok pixaWriteFiles(const char*, PIXA*, l_int32)
    • pixWrite

      int pixWrite(String fname, Pix pix, int format)
      Original signature : l_ok pixWrite(const char*, PIX*, l_int32)
    • pixWriteAutoFormat

      int pixWriteAutoFormat(String filename, Pix pix)
      Original signature : l_ok pixWriteAutoFormat(const char*, PIX*)
    • pixWriteStream

      int pixWriteStream(ILeptonica.FILE fp, Pix pix, int format)
      Original signature : l_ok pixWriteStream(FILE*, PIX*, l_int32)
    • pixWriteImpliedFormat

      int pixWriteImpliedFormat(String filename, Pix pix, int quality, int progressive)
      Original signature : l_ok pixWriteImpliedFormat(const char*, PIX*, l_int32, l_int32)
    • pixChooseOutputFormat

      int pixChooseOutputFormat(Pix pix)
      Original signature : l_int32 pixChooseOutputFormat(PIX*)
    • getImpliedFileFormat

      int getImpliedFileFormat(String filename)
      Original signature : l_int32 getImpliedFileFormat(const char*)
    • pixGetAutoFormat

      int pixGetAutoFormat(Pix pix, IntBuffer pformat)
      Original signature : l_ok pixGetAutoFormat(PIX*, l_int32*)
    • getFormatExtension

      com.sun.jna.Pointer getFormatExtension(int format)
      Original signature : char* getFormatExtension(l_int32)
    • pixWriteMem

      int pixWriteMem(com.sun.jna.ptr.PointerByReference pdata, NativeSizeByReference psize, Pix pix, int format)
      Original signature : l_ok pixWriteMem(l_uint8**, size_t*, PIX*, l_int32)
    • l_fileDisplay

      int l_fileDisplay(String fname, int x, int y, float scale)
      Original signature : l_ok l_fileDisplay(const char*, l_int32, l_int32, l_float32)
    • pixDisplay

      int pixDisplay(Pix pixs, int x, int y)
      Original signature : l_ok pixDisplay(PIX*, l_int32, l_int32)
    • pixDisplayWithTitle

      int pixDisplayWithTitle(Pix pixs, int x, int y, String title, int dispflag)
      Original signature : l_ok pixDisplayWithTitle(PIX*, l_int32, l_int32, const char*, l_int32)
    • pixDisplayWrite

      int pixDisplayWrite(Pix pixs, int reduction)
      Original signature : l_ok pixDisplayWrite(PIX*, l_int32)
    • zlibCompress

      com.sun.jna.Pointer zlibCompress(ByteBuffer datain, NativeSize nin, NativeSizeByReference pnout)
      Original signature : l_uint8* zlibCompress(const l_uint8*, size_t, size_t*)
    • zlibUncompress

      com.sun.jna.Pointer zlibUncompress(ByteBuffer datain, NativeSize nin, NativeSizeByReference pnout)
      Original signature : l_uint8* zlibUncompress(const l_uint8*, size_t, size_t*)