|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
| Packages that use FloatImage | |
|---|---|
| Facemorph | |
| Facemorph.aam | |
| Facemorph.mdl | |
| Facemorph.multifilter | |
| Facemorph.oesf | |
| Facemorph.psm | |
| Facemorph.psychomorph | |
| Facemorph.tensor | |
| Uses of FloatImage in Facemorph |
|---|
| Fields in Facemorph declared as FloatImage | |
|---|---|
FloatImage[] |
Pyramid.horizontal
The set of horizontally filtered images at different resolutions |
FloatImage |
Pyramid.smooth
The low pass residual |
FloatImage[] |
Pyramid.vertical
The set of vertically filtered images at different resolutions |
| Methods in Facemorph that return FloatImage | |
|---|---|
static FloatImage[] |
FloatImage.calculateCurvature(FloatImage[] pmap,
int scale)
Calculates the curvature after scaling by the amount indicated |
static FloatImage |
FloatImage.combineUV(FloatImage U,
FloatImage V)
Attempts to combine the U and V components to a single channel for skin detection using U*U*(U*U-U/V)*(U*U-U/V) |
FloatImage[] |
Template.constructMultilinearFitter(int warpType,
java.awt.Image averageImage,
Template avrg,
Mask mask,
Multilinear shapeMultilinear,
Multilinear imageMultilinear,
float scale)
Constructs the data needed for fitting a multilinear AAM to an image using efficient reverse method, with linear projection model, includes colour information |
FloatImage |
FloatImage.copy()
Creates and returns a copy of this image |
static FloatImage |
FloatImage.createColourHistogram(FloatImage R,
FloatImage G,
FloatImage B)
Creates a 2D colour histogram (R/(R+G+B), G/(R+G+B)) for an image. |
static FloatImage |
FloatImage.createColourHistogram(FloatImage R,
FloatImage G,
FloatImage B,
FloatImage mask)
Creates a 2D colour histogram (R/(R+G+B), G/(R+G+B)) for part of an image defines by a mask. |
static FloatImage[] |
FloatImage.deinterleaveImages(FloatImage rgb)
Take an interleaved image, eg. |
FloatImage |
AWN.draw(int w,
int h)
Draws the wavelets to a FloatImage |
FloatImage |
FloatImage.erodeMask()
Perform binary erosion on this FloatImage, any pixels adjacent to zero values are set to zero |
FloatImage[] |
PCI.getAverage()
Retrieves the average image as an array of FloatImage |
FloatImage[] |
PCI.getComponent(int i)
Retrieve a specific component |
FloatImage[][] |
PCI.getIntersection(PCI pci,
Mask mask)
Gets the intersection or closest point between two PCIs |
FloatImage[][] |
PCI.getIntersectionIterative(PCI pci,
Mask mask)
Gets the intersection or closest point between two PCIs |
FloatImage |
Template.getMask(Mask mask,
int w,
int h,
float min,
float max)
Constructs a FloatImage with values of 0 (masked) and max (not masked) |
FloatImage |
Template.getMask(java.util.Vector<java.lang.Integer> maskConts,
java.util.Vector<java.lang.Integer> maskDirections,
int w,
int h,
float min,
float max)
Constructs a FloatImage with values of 0 (masked) and max (not masked) |
FloatImage |
FloatImage.getSubImage(int x,
int y,
int w,
int h)
Gets a sub-part of this image |
static FloatImage |
FloatImage.interleaveImages(FloatImage red,
FloatImage green,
FloatImage blue)
Turn separate three red green and blue images into one image by interleaving the pixels |
FloatImage[] |
PCI.reconstruct(float[] params)
reconstructs an image given the component weightings |
FloatImage[] |
PCI.reconstruct(float[] params,
FloatImage[] avrg)
reconstructs an image given the component weightings, using avrg instead of the built in average |
static FloatImage[] |
PCI.reconstructFile(float[] params,
FloatImage[] avrg,
int pcaCount)
reconstructs an image given the component weightings, using avrg instead of the built in average |
FloatImage[] |
PCI.reconstructMaxWeights(float[] params)
Build an image from PCA components using the weights given after rescaling them by the maxWeights array |
FloatImage[] |
PCI.reconstructMaxWeights(float[] params,
FloatImage[] avrg)
Build an image from PCA components using the weights given after rescaling them by the maxWeights array. |
FloatImage |
FloatImage.reduce(FloatImage fimg,
FloatImage mask,
float[] filter,
int m)
Make this a shrunken version of fimg by subsampling every other pixel (in x and y) after convolving with filter |
FloatImage |
FloatImage.resize(int w,
int h)
Resize this image using bilinear resampling to the specified dimensions |
FloatImage |
FloatImage.shift(float w,
float t)
Creates a scaled and shift version of this image i.e. |
FloatImage |
FloatImage.transform(float[][] mat,
int w,
int h)
Perform an affine transform on the image geometry |
FloatImage |
FloatImage.warp(FloatImage xshift,
FloatImage yshift,
int w,
int h)
Warps this using the x and y shifts specified and returns the result as a w by h size image |
FloatImage |
Warp.warpFloatImage(FloatImage fimg)
Warp a FloatImage using this warping function |
FloatImage |
FloatImage.warpShift(FloatImage xshift,
FloatImage yshift,
int w,
int h)
Warps this using the x and y functions specified and returns the result as a w by h size image |
| Methods in Facemorph with parameters of type FloatImage | |
|---|---|
boolean |
FloatImage.adaptAverage(FloatImage varSquared)
Adapts the average to have the same locally smoothed magnitude as varSquared |
boolean |
FloatImage.add(FloatImage fimg)
Adds fimg to this to give this = this + fimg |
boolean |
FloatImage.add(FloatImage fimg,
float w)
Adds a scaled amount of fimg to this to give this = this + w*fimg |
void |
FloatImage.add(FloatImage fimg1,
FloatImage fimg2)
Adds two FloatImages, putting the result in this |
void |
Pyramid.add(FloatImage image,
int level)
|
int |
FloatImage.addToAverage(FloatImage fimg,
int n)
Adds an image into this average image |
boolean |
FloatImage.addToVariance(FloatImage fimg1,
FloatImage fimg2,
int n)
Adds fimg1 and fimg2 to this complex magnitude average as the real and imaginary parts |
boolean |
FloatImage.addToVariance(FloatImage fimg1,
int n)
Adds fimg1 to the average of absolute values |
boolean |
FloatImage.addToVarianceSquared(FloatImage fimg1,
int n)
Add fimg1 to the average of squared images |
int |
FloatImage.adjust(FloatImage xshift,
FloatImage yshift,
FloatImage xtmp,
FloatImage ytmp)
Replaces xshift(x,y)=xtmp(x,y) and yshift(x,y)=ytmp(x,y at locations where this(x,y)=0 |
float[] |
PCI.analyse(FloatImage[] fimg)
Analyses the given image to gives the weights of the principal components |
float[] |
PCI.analyse(FloatImage[] fimg,
FloatImage mask)
Analyses the given image to gives the weights of the principal components |
float[] |
PCI.analyse(FloatImage[] fimg,
FloatImage mask)
Analyses the given image to gives the weights of the principal components |
static float[] |
PCI.analyseFile(FloatImage[] fimg,
FloatImage mask,
int pcaCount)
Analyses the given image to gives the weights of the principal components |
static float[] |
PCI.analyseFile(FloatImage[] fimg,
FloatImage mask,
int pcaCount)
Analyses the given image to gives the weights of the principal components |
double[] |
PCI.analyseLS(FloatImage[] fimg,
FloatImage mask)
Analyses the given image to gives the weights of the principal components |
double[] |
PCI.analyseLS(FloatImage[] fimg,
FloatImage mask)
Analyses the given image to gives the weights of the principal components |
double[] |
PCW.analyseMasked(Pyramid pyr,
FloatImage mask)
Finds the weights of this Pyramid after masking |
float[] |
PCI.analyseMaxWeights(FloatImage[] fimg)
Analyses the given image to gives the weights of the principal components |
void |
PCI.build(java.util.ArrayList<java.awt.image.BufferedImage> images,
double varianceToExplain,
FloatImage mask)
Method to create a PCI from a set of delineated images. |
void |
PCI.build(Template avTem,
FloatImage[] avImg,
java.awt.Image[] images,
Template[] templates,
FloatImage mask,
double varianceToExplain)
Method to create a PCI from a set of delineated images. |
void |
PCI.build(Template avTem,
FloatImage[] avImg,
java.awt.Image[] images,
Template[] templates,
FloatImage mask,
double varianceToExplain)
Method to create a PCI from a set of delineated images. |
void |
PCI.buildFloatImage(java.util.ArrayList<FloatImage[]> images,
FloatImage mask,
double varianceToExplain)
Method to create a PCI from a set of delineated images. |
static double[] |
PCI.buildWarpedFiles(int number,
double varianceToExplain,
FloatImage[] average,
FloatImage mask)
Method to create a PCI from a set of pre-warped images, which are read from files with names of the form "warped"+i+"_"+k+".fimg" where k is 0, 1 or 2 for r, g and b. |
static double[] |
PCI.buildWarpedFiles(int number,
double varianceToExplain,
FloatImage[] average,
FloatImage mask)
Method to create a PCI from a set of pre-warped images, which are read from files with names of the form "warped"+i+"_"+k+".fimg" where k is 0, 1 or 2 for r, g and b. |
static FloatImage[] |
FloatImage.calculateCurvature(FloatImage[] pmap,
int scale)
Calculates the curvature after scaling by the amount indicated |
void |
BSplineQuadTree.calculateInterpConstraints(int maxLev,
FloatImage mask,
FloatImage xshift,
FloatImage yshift)
Calculate the interpolation with the constraints given as a set of FloatImages |
void |
BSplineQuadTree.calculateWarpConstraints(int maxLev,
FloatImage mask,
FloatImage xshift,
FloatImage yshift)
Calculate the warp with constraints specified in FloatImages |
void |
FloatImage.classify(FloatImage R,
FloatImage G,
FloatImage B,
FloatImage probCol,
FloatImage probColGivenSkin)
Classifies the liklihood of pixels in an image belonging to the class defined by 2 histograms. |
static FloatImage |
FloatImage.combineUV(FloatImage U,
FloatImage V)
Attempts to combine the U and V components to a single channel for skin detection using U*U*(U*U-U/V)*(U*U-U/V) |
void |
Warp.convert(FloatImage Wx,
FloatImage Wy)
Converts this warp into the two FloatImages |
static void |
FloatImage.convertImage(java.awt.image.BufferedImage img,
FloatImage red,
FloatImage green,
FloatImage blue)
Converts a BufferedImage into three FloatImages for red, green and blue |
static boolean |
FloatImage.convertImage(java.awt.Image img,
FloatImage R,
FloatImage G,
FloatImage B,
java.awt.image.ImageObserver ob)
Splits a colour image into 3 FloatImages |
static boolean |
FloatImage.convertImageHSV(java.awt.Image img,
FloatImage H,
FloatImage S,
FloatImage V,
java.awt.image.ImageObserver ob)
Splits a colour image into 3 FloatImages Note: this isn't proper HSV, more like YUV components, with UV converted to polar coords ... |
static boolean |
FloatImage.convertImageLAB(java.awt.Image img,
FloatImage L,
FloatImage A,
FloatImage B,
java.awt.image.ImageObserver ob)
Splits a colour image into 3 (LAB) component FloatImages |
static boolean |
FloatImage.convertImageRGB(java.awt.Image img,
FloatImage R,
FloatImage G,
FloatImage B,
java.awt.image.ImageObserver ob)
Splits a colour image into 3 FloatImages |
static boolean |
FloatImage.convertImageYUV(java.awt.Image img,
FloatImage Y,
FloatImage U,
FloatImage V,
java.awt.image.ImageObserver ob)
Splits a colour image into 3 (YUV) component FloatImages |
static void |
FloatImage.convertInterleaveImageRGB(java.awt.image.BufferedImage img,
FloatImage rgb)
Converts a BufferedImage into one interleaved FloatImages in Red, Green, Blue order |
static java.awt.Image |
FloatImage.convertToImage(FloatImage R,
FloatImage G,
FloatImage B)
Create a colour image from three float images representing the R, G and B components |
static java.awt.Image |
FloatImage.convertToImageYUV(FloatImage Y,
FloatImage U,
FloatImage V)
Create a colour image from three float images representing the Y, U and V components |
void |
FloatImage.convolve_x(FloatImage fimg,
float[] filter,
int m,
int scale)
Filter this FloatImage in the x direction |
void |
FloatImage.convolve_x(FloatImage fimg,
FloatImage mask,
float[] filter,
int m,
int scale)
Filter this FloatImage in the x direction with masking |
void |
FloatImage.convolve_y(FloatImage fimg,
float[] filter,
int m,
int scale)
Filter this FloatImage in the y direction |
void |
FloatImage.convolve_y(FloatImage fimg,
FloatImage mask,
float[] filter,
int m,
int scale)
Filter this FloatImage in the y direction with masking |
void |
FloatImage.convolve(FloatImage fimg,
float[][] filter,
int m,
int n,
int scale)
Non-separable convolution |
void |
FloatImage.convolve(FloatImage mask,
float[] filter,
int m,
int scale)
Filter the image in the x and y directions (separably) with the filter specified with masking |
void |
FloatImage.convolve(FloatImage fimg,
FloatImage filter,
int m,
int n,
int scale)
Convolve this float image with a filter defined by an image |
boolean |
FloatImage.convolveFFT(FloatImage fimg1,
FloatImage fimg2,
boolean inverse)
FFT based convolution, the result is put in this |
void |
FloatImage.copy(FloatImage fimg)
Copy fimg into this |
int |
FloatImage.correlationFFT(FloatImage fimg1,
FloatImage fimg2)
Correlation using FFT, the result is held in this |
static FloatImage |
FloatImage.createColourHistogram(FloatImage R,
FloatImage G,
FloatImage B)
Creates a 2D colour histogram (R/(R+G+B), G/(R+G+B)) for an image. |
static FloatImage |
FloatImage.createColourHistogram(FloatImage R,
FloatImage G,
FloatImage B,
FloatImage mask)
Creates a 2D colour histogram (R/(R+G+B), G/(R+G+B)) for part of an image defines by a mask. |
java.util.ArrayList<KdTreePoint> |
FloatImage.createTreePoints(FloatImage edges,
FloatImage xdir,
FloatImage ydir,
FloatImage xxdir,
FloatImage yydir,
FloatImage xydir)
Create an array of kd tree points using pre-selected edge points |
static FloatImage[] |
FloatImage.deinterleaveImages(FloatImage rgb)
Take an interleaved image, eg. |
static void |
FloatImage.deinterleaveImages(FloatImage rgb,
FloatImage red,
FloatImage green,
FloatImage blue)
|
boolean |
FloatImage.divide(FloatImage fimg,
float tol)
Divides this image by fimg to give this = this / fimg |
int |
FloatImage.divide(FloatImage f,
FloatImage g)
Pixelwise divide f and g by this and set this to 1 (where this is not zero) |
float |
FloatImage.dotProduct(FloatImage fimg)
Finds the dot product (aka scalar product or sum of pixel products) of this image with fimg |
float |
FloatImage.dotProduct(FloatImage fimg,
FloatImage mask)
Finds the dot product (aka scalar product or sum of pixel products) of a masked part of this image with fimg |
double |
Pyramid.dotProduct(Pyramid pyr,
FloatImage mask)
Dot product, each level's contribution scaled up to match largest |
void |
FloatImage.dual_convolve_x(FloatImage fimg,
float[] filter1,
float[] filter2,
int m1,
int m2,
int bm)
Convolves in x-direction with two different filters at odd and even pixels respectively |
void |
FloatImage.dual_convolve_y(FloatImage fimg,
float[] filter1,
float[] filter2,
int m1,
int m2,
int bm)
Convolves in y-direction with two different filters at odd and even pixels respectively |
void |
FloatImage.edgeMagnitude(FloatImage dx,
FloatImage dy)
Calculates the magnitude of edges |
void |
FloatImage.edgeWarp(FloatImage dest,
MultiscaleWarp shift,
int level,
int warpType,
java.lang.String output)
Non-recursive edge matching |
void |
FloatImage.expand(FloatImage fimg,
float[] filter,
int m)
Make a double sized version of this and put it in fimg, the filter is used after placing zeros between rows and cols |
void |
FloatImage.expand(FloatImage fimg,
float[] filter,
int m,
int outW,
int outH)
Make a double sized version of this and put it in fimg, the filter is used after placing zeros between rows and cols |
void |
Template.fitAAMshape(int warpType,
FloatImage average,
FloatImage subject,
Template avrg,
Mask mask,
PCA pca,
float scale)
First attempt at fitting an AAM to an image, does not include colour information, not recommended to use! |
int |
Template.fitAAMspan(int warpType,
java.awt.Image subject,
java.awt.Image averageImg,
Mask mask,
PCA pca,
PCI pci,
FloatImage[] smallPCIcomps,
float scale,
int counter)
Attempt at fitting an AAM to an image using efficient reverse method, colour information is projected out |
void |
Template.fitMultilinear(java.awt.Image subject,
java.awt.Image averageImage,
Template avrg,
Mask mask,
Multilinear shapeMultilinear,
Multilinear imageMultilinear,
FloatImage[] diffImg,
float scale)
Uses a multilinear fitting model to try a fit a template to the image |
void |
Template.fitPCA(FloatImage average,
FloatImage subject,
Template avrg,
PCA pca,
int leftIndex,
int rightIndex,
int mouthIndex)
Fits a Template to this FloatImage |
void |
AWN.fitToImage(FloatImage fimg)
Attempt to fit a wavelet network to an image |
static float |
FloatImage.germanMcClure(FloatImage[] fimg,
FloatImage[] av,
float d)
Calculates the German-McClure error function between this and fimg using weighting d |
static float |
FloatImage.germanMcClure(FloatImage[] fimg,
FloatImage[] av,
float d)
Calculates the German-McClure error function between this and fimg using weighting d |
float |
FloatImage.germanMcClure(FloatImage fimg,
float d)
Calculates the German-McClure error function between this and fimg using weighting d |
int |
FloatImage.getMatchingPoints(FloatImage dest_edge,
FloatImage[] sourceData,
FloatImage[] destData,
java.util.ArrayList<java.awt.geom.Point2D.Float> srcPts,
java.util.ArrayList<java.awt.geom.Point2D.Float> dstPts)
Gets two-way matching points |
int |
FloatImage.getMatchingPoints(FloatImage dest_edge,
FloatImage[] sourceData,
FloatImage[] destData,
java.util.ArrayList<java.awt.geom.Point2D.Float> srcPts,
java.util.ArrayList<java.awt.geom.Point2D.Float> dstPts)
Gets two-way matching points |
int |
FloatImage.getMatchingPoints(FloatImage dest_edge,
FloatImage[] sourceData,
FloatImage[] destData,
java.util.ArrayList<java.awt.geom.Point2D.Float> srcPts,
java.util.ArrayList<java.awt.geom.Point2D.Float> dstPts)
Gets two-way matching points |
float[] |
FloatImage.getMeanAndSD(FloatImage mask)
Get the mean and standard deviation of this image |
int |
FloatImage.icpEdgeWarp(FloatImage dest,
MultiscaleWarp shift,
int minwidth)
Iterative closest point warp |
static FloatImage |
FloatImage.interleaveImages(FloatImage red,
FloatImage green,
FloatImage blue)
Turn separate three red green and blue images into one image by interleaving the pixels |
boolean |
MultiscaleInterpolate.interpolate(FloatImage mask,
FloatImage data)
Interpolates the data using the mask to specify valid samples |
int |
FloatImage.interpolate(FloatImage xshift,
FloatImage yshift,
float[] f1,
float[] f2,
int n1,
int n2,
int levels,
float minJ,
int rlevel)
Performs a multiscale interpolation scheme |
void |
FloatImage.invScale(FloatImage fimg)
Scale each pixel in this image by the inverse of the value of the corresponding pixel in the other image |
boolean |
FloatImage.mask(FloatImage maskImg)
Masks this FloatImage |
boolean |
FloatImage.mask(FloatImage maskImg,
float outside)
Masks this FloatImage |
int |
FloatImage.maxima(FloatImage xdir,
FloatImage ydir,
FloatImage edges,
float thresh)
Find the maxima in the directions given |
java.util.ArrayList<KdTreePoint> |
FloatImage.maxima(FloatImage xdir,
FloatImage ydir,
FloatImage xxdir,
FloatImage yydir,
FloatImage xydir,
float thresh)
Create a kd-tree of maxima points using edge information |
int |
FloatImage.multiEdgeWarp(FloatImage dest,
FloatImage[] pmapSrc,
FloatImage[] pmapDst,
MultiscaleWarp shift,
int minwidth,
int level)
Multiscale edge based warping with curvature |
int |
FloatImage.multiEdgeWarp(FloatImage dest,
FloatImage[] pmapSrc,
FloatImage[] pmapDst,
MultiscaleWarp shift,
int minwidth,
int level)
Multiscale edge based warping with curvature |
int |
FloatImage.multiEdgeWarp(FloatImage dest,
FloatImage[] pmapSrc,
FloatImage[] pmapDst,
MultiscaleWarp shift,
int minwidth,
int level)
Multiscale edge based warping with curvature |
int |
FloatImage.multiEdgeWarp(FloatImage dest,
FloatImage xshift,
FloatImage yshift)
Edge based warping method |
void |
FloatImage.multiEdgeWarp(FloatImage dest,
MultiscaleWarp shift,
int minwidth,
int warpType)
Recursive edge matching & warping |
void |
FloatImage.multiEdgeWarp(FloatImage dest,
MultiscaleWarp shift,
int minwidth,
int level,
boolean allscales,
int warpType,
java.lang.String output)
Recursive edge matching & warping |
boolean |
FloatImage.multiply(FloatImage fimg)
Mulitplies this image by fimg to give this = this * fimg |
void |
FloatImage.multiscaleOpticFlow(FloatImage target,
MultiscaleWarp shift,
int minwidth)
Multi scale optical flow method |
int |
FloatImage.MultiscaleTransformWaveletMRF_fast2(FloatImage original,
java.util.ArrayList<FloatImage> source,
java.util.ArrayList<FloatImage> target,
int lev,
Filter H,
Filter G,
Filter H2,
Filter K1,
Filter K2,
Filter L1,
Filter L2)
Algorithm for each source image calculate the low pass version (save for pass to recursive call), calculate the horizontal and vertical wavelet filtered versions, Calculate the low pass version of the input image via recursive call Estimate the horizontal and vertical images using MRF method on wavelet & low pass images Reconstruct image using low-pass and horizontal & vertical wavelets |
float |
FloatImage.ncc(FloatImage fimg)
Calculates the normalised cross correlation (NCC) with fimg |
float |
FloatImage.ncc(FloatImage fimg,
FloatImage mask)
Calculates the normalised cross correlation (NCC) with fimg using only the masked regions |
float |
FloatImage.nccPatch(FloatImage fimg,
int x,
int y)
Calculates the normalised cross correlation (NCC) with fimg |
float[] |
FloatImage.nccPatchArray(FloatImage fimg)
Calculates the normalised cross correlation (NCC) with fimg |
float |
FloatImage.nccPatches(FloatImage fimg)
Calculates the normalised cross correlation (NCC) with fimg |
void |
FloatImage.normalise(float mean,
float sd,
FloatImage mask)
Adjusts this image to have the specified mean and s.d. |
void |
FloatImage.normalise(FloatImage fimg)
Adjusts this image to have the same mean and s.d. |
void |
FloatImage.normalise(FloatImage fimg,
FloatImage mask)
Adjusts this image to have the same mean and s.d. |
void |
FloatImage.opticFlow(FloatImage target,
MultiscaleWarp shift)
Basic optical flow implementation |
FloatImage[] |
PCI.reconstruct(float[] params,
FloatImage[] avrg)
reconstructs an image given the component weightings, using avrg instead of the built in average |
static FloatImage[] |
PCI.reconstructFile(float[] params,
FloatImage[] avrg,
int pcaCount)
reconstructs an image given the component weightings, using avrg instead of the built in average |
FloatImage[] |
PCI.reconstructMaxWeights(float[] params,
FloatImage[] avrg)
Build an image from PCA components using the weights given after rescaling them by the maxWeights array. |
void |
Warp.reconvert(FloatImage Wx,
FloatImage Wy)
Converts the warp sepcified as two float images into this |
static java.awt.image.BufferedImage |
FloatImage.reconvertImage(FloatImage red,
FloatImage green,
FloatImage blue)
Converts the red, green and blue colour components into a BufferedImage |
static java.awt.image.BufferedImage |
FloatImage.reconvertImage(FloatImage red,
FloatImage green,
FloatImage blue,
FloatImage alpha)
Converts the red, green and blue colour components into a BufferedImage |
static java.awt.image.BufferedImage |
FloatImage.reconvertImageYUV(FloatImage Y,
FloatImage U,
FloatImage V)
Create a colour image from three float images representing the Y, U and V components |
void |
FloatImage.reduce(FloatImage fimg,
float[] filter,
int m)
Make this a shrunken version of fimg by subsampling every other pixel (in x and y) after convolving with filter |
FloatImage |
FloatImage.reduce(FloatImage fimg,
FloatImage mask,
float[] filter,
int m)
Make this a shrunken version of fimg by subsampling every other pixel (in x and y) after convolving with filter |
void |
FloatImage.reduce(FloatImage fimg,
FloatImage filter,
int m)
Make this a shrunken version of fimg by subsampling every other pixel (in x and y) after convolving with filter |
void |
FloatImage.scale(FloatImage fimg)
Scale each pixel in this image by the value of the corresponding pixel in the other image |
void |
PCI.setAverage(FloatImage red,
FloatImage green,
FloatImage blue)
Sets the values of the mean image |
void |
PCI.setComponent(int i,
FloatImage[] fimg)
Set one component |
void |
PCI.setComponents(FloatImage[][] comps,
double[] variances)
Sets the components and their variances |
void |
Pyramid.setImage(FloatImage img)
Set the low pass residual (at level 0) and delete the bandpass images |
void |
FloatImage.sqrDifference(FloatImage fimg,
FloatImage filter,
int m,
int n,
int scale)
find the square difference between this float image with a filter defined by an image using a windowing technique |
boolean |
FloatImage.subtract(FloatImage fimg)
Subtracts fimg from this i.e. |
void |
Pyramid.subtract(FloatImage image,
int level)
|
static int |
FloatImage.subtractIgnoreZeros(FloatImage[] current,
FloatImage[] fimg)
Subtracts fimg from current i.e. |
static int |
FloatImage.subtractIgnoreZeros(FloatImage[] current,
FloatImage[] fimg)
Subtracts fimg from current i.e. |
static float |
FloatImage.sumError(FloatImage[] fimg,
FloatImage[] av)
Calculates the sum error function between this and fimg using weighting d |
static float |
FloatImage.sumError(FloatImage[] fimg,
FloatImage[] av)
Calculates the sum error function between this and fimg using weighting d |
static float |
FloatImage.sumErrorSquared(FloatImage[] fimg,
FloatImage[] av)
Calculates the sum squared error function between this and fimg using weighting d |
static float |
FloatImage.sumErrorSquared(FloatImage[] fimg,
FloatImage[] av)
Calculates the sum squared error function between this and fimg using weighting d |
int |
FloatImage.threshold(FloatImage edges,
float thresh)
Find the points bigger than the threshold |
int |
FloatImage.thresholdPercent(FloatImage edges,
float thresh)
Thresholds the image at a certain percentage of points are kept |
void |
Template.trackASM(FloatImage average,
FloatImage subject,
Template avrg,
PCA pca,
float scale,
int its,
int[] normalisePointIndex)
Fits a PCA model to an image using edge normal profiles |
int |
FloatImage.transform(FloatImage src,
FloatImage dst,
float scale)
Transforms the image by adding (dst-src)*scale |
boolean |
FloatImage.transformMagnitude(FloatImage var1,
FloatImage var2,
float shift)
Transforms this by multiplying by var2(x,y)/var1(x,y)^shift |
boolean |
FloatImage.transformMagSquared(FloatImage var1,
FloatImage var2,
float shift)
Transforms this by multiplying by var2(x,y)/var1(x,y)^(shift*0.5) |
static double[] |
FloatImage.vectorise(FloatImage[] colImg)
Vectorises a colour image stored as 3 FloatImages. |
FloatImage |
FloatImage.warp(FloatImage xshift,
FloatImage yshift,
int w,
int h)
Warps this using the x and y shifts specified and returns the result as a w by h size image |
FloatImage |
Warp.warpFloatImage(FloatImage fimg)
Warp a FloatImage using this warping function |
FloatImage |
FloatImage.warpShift(FloatImage xshift,
FloatImage yshift,
int w,
int h)
Warps this using the x and y functions specified and returns the result as a w by h size image |
int |
FloatImage.weightedTransformMRFHorizontal(FloatImage original,
FloatImage this_small,
FloatImage original_small,
FloatImage magnitude,
FloatImage[] source,
java.util.ArrayList<FloatImage> source_small,
int scount,
FloatImage[] target,
java.util.ArrayList<FloatImage> target_small,
int tcount,
double alpha)
MRF transform method |
int |
FloatImage.weightedTransformMRFHorizontal(FloatImage original,
FloatImage this_small,
FloatImage original_small,
FloatImage magnitude,
FloatImage[] source,
java.util.ArrayList<FloatImage> source_small,
int scount,
FloatImage[] target,
java.util.ArrayList<FloatImage> target_small,
int tcount,
double alpha)
MRF transform method |
int |
FloatImage.weightedTransformMRFHorizontal(FloatImage original,
FloatImage this_small,
FloatImage original_small,
FloatImage magnitude,
FloatImage[] source,
java.util.ArrayList<FloatImage> source_small,
int scount,
FloatImage[] target,
java.util.ArrayList<FloatImage> target_small,
int tcount,
double alpha)
MRF transform method |
int |
FloatImage.weightedTransformMRFVertical(FloatImage original,
FloatImage this_small,
FloatImage original_small,
FloatImage magnitude,
FloatImage[] source,
java.util.ArrayList<FloatImage> source_small,
int scount,
FloatImage[] target,
java.util.ArrayList<FloatImage> target_small,
int tcount,
double alpha)
MRF transform method |
int |
FloatImage.weightedTransformMRFVertical(FloatImage original,
FloatImage this_small,
FloatImage original_small,
FloatImage magnitude,
FloatImage[] source,
java.util.ArrayList<FloatImage> source_small,
int scount,
FloatImage[] target,
java.util.ArrayList<FloatImage> target_small,
int tcount,
double alpha)
MRF transform method |
int |
FloatImage.weightedTransformMRFVertical(FloatImage original,
FloatImage this_small,
FloatImage original_small,
FloatImage magnitude,
FloatImage[] source,
java.util.ArrayList<FloatImage> source_small,
int scount,
FloatImage[] target,
java.util.ArrayList<FloatImage> target_small,
int tcount,
double alpha)
MRF transform method |
void |
FloatImage.writeCurvImage(FloatImage[] srcCurv,
java.lang.String outfile)
Writes a curvature image to file |
| Method parameters in Facemorph with type arguments of type FloatImage | |
|---|---|
int |
FloatImage.MultiscaleBlendWaveletMRF_fast2(java.util.ArrayList<FloatImage> source,
int count,
int lev,
Filter H,
Filter G,
Filter H2,
Filter K1,
Filter K2,
Filter L1,
Filter L2)
Blends a set of greyscale images using a multiscale MRF method Algorithm for each source image calculate the low pass version (save for pass to recursive call), calculate the horizontal and vertical wavelet filtered versions, Calculate the low pass version of the input image via recursive call Estimate the horizontal and vertical images using MRF method on wavelet & low pass images Reconstruct image using low-pass and horizontal & vertical wavelets |
int |
FloatImage.MultiscaleTransformWaveletMRF_fast2(FloatImage original,
java.util.ArrayList<FloatImage> source,
java.util.ArrayList<FloatImage> target,
int lev,
Filter H,
Filter G,
Filter H2,
Filter K1,
Filter K2,
Filter L1,
Filter L2)
Algorithm for each source image calculate the low pass version (save for pass to recursive call), calculate the horizontal and vertical wavelet filtered versions, Calculate the low pass version of the input image via recursive call Estimate the horizontal and vertical images using MRF method on wavelet & low pass images Reconstruct image using low-pass and horizontal & vertical wavelets |
int |
FloatImage.MultiscaleTransformWaveletMRF_fast2(FloatImage original,
java.util.ArrayList<FloatImage> source,
java.util.ArrayList<FloatImage> target,
int lev,
Filter H,
Filter G,
Filter H2,
Filter K1,
Filter K2,
Filter L1,
Filter L2)
Algorithm for each source image calculate the low pass version (save for pass to recursive call), calculate the horizontal and vertical wavelet filtered versions, Calculate the low pass version of the input image via recursive call Estimate the horizontal and vertical images using MRF method on wavelet & low pass images Reconstruct image using low-pass and horizontal & vertical wavelets |
int |
FloatImage.weightedTransformMRFHorizontal(FloatImage original,
FloatImage this_small,
FloatImage original_small,
FloatImage magnitude,
FloatImage[] source,
java.util.ArrayList<FloatImage> source_small,
int scount,
FloatImage[] target,
java.util.ArrayList<FloatImage> target_small,
int tcount,
double alpha)
MRF transform method |
int |
FloatImage.weightedTransformMRFHorizontal(FloatImage original,
FloatImage this_small,
FloatImage original_small,
FloatImage magnitude,
FloatImage[] source,
java.util.ArrayList<FloatImage> source_small,
int scount,
FloatImage[] target,
java.util.ArrayList<FloatImage> target_small,
int tcount,
double alpha)
MRF transform method |
int |
FloatImage.weightedTransformMRFVertical(FloatImage original,
FloatImage this_small,
FloatImage original_small,
FloatImage magnitude,
FloatImage[] source,
java.util.ArrayList<FloatImage> source_small,
int scount,
FloatImage[] target,
java.util.ArrayList<FloatImage> target_small,
int tcount,
double alpha)
MRF transform method |
int |
FloatImage.weightedTransformMRFVertical(FloatImage original,
FloatImage this_small,
FloatImage original_small,
FloatImage magnitude,
FloatImage[] source,
java.util.ArrayList<FloatImage> source_small,
int scount,
FloatImage[] target,
java.util.ArrayList<FloatImage> target_small,
int tcount,
double alpha)
MRF transform method |
| Uses of FloatImage in Facemorph.aam |
|---|
| Methods in Facemorph.aam that return FloatImage | |
|---|---|
static FloatImage |
FBOwarp.getAlpha(java.awt.image.BufferedImage bimg)
Gets the alpha channel from the image |
static FloatImage |
OpenGLwarp.getAlpha(java.awt.image.BufferedImage bimg)
Get the alpha channel as a FloatImage |
FloatImage[] |
FBOwarp.getResult()
Get the warped image as an array of 3 FloatImage |
FloatImage[] |
OpenGLwarp.getResult()
Get the warped image |
FloatImage[] |
FBOwarp.getResult(boolean alpha)
Get the warped image as an array of 3 or 4 FloatImage |
FloatImage[] |
OpenGLwarp.getResult(boolean alpha)
Get the warped image |
FloatImage |
CLM.getStrip(Template tem,
FloatImage fimg,
java.awt.Rectangle rect)
Gets the patches from all points arranged in a strip |
FloatImage[] |
CLMLR.getStrip(Template tem,
FloatImage fimg,
java.awt.Rectangle rect,
int minOffset,
int maxOffset)
Gets the patches from all points arranged in a strip |
FloatImage[] |
CLMSVM.getStrip(Template tem,
FloatImage fimg,
java.awt.Rectangle rect,
int minOffset,
int maxOffset)
Gets the patches from all points arranged in a strip |
FloatImage |
CLM.project(FloatImage strip)
Projects the sampled patches into the patch model space |
FloatImage[] |
AAM.reconstructAppearance(float[] params)
reconstructs an image given the component weightings, using avrg instead of the built in average |
FloatImage[] |
GLAAM.reconstructAppearance(float[] params)
reconstructs an image given the component weightings, using avrg instead of the built in average |
| Methods in Facemorph.aam with parameters of type FloatImage | |
|---|---|
float[] |
AAM.analyseAppearance(FloatImage[] data)
reconstructs an image given the component weightings, using avrg instead of the built in average |
float[] |
GLAAM.analyseAppearance(FloatImage[] data)
reconstructs an image given the component weightings, using avrg instead of the built in average |
double[] |
AAM.convertFloatImage(FloatImage[] img)
Converts a FloatImage to a double array |
double[] |
GLAAM.convertFloatImage(FloatImage[] img)
Converts a FloatImage to a double array |
FloatImage |
CLM.getStrip(Template tem,
FloatImage fimg,
java.awt.Rectangle rect)
Gets the patches from all points arranged in a strip |
FloatImage[] |
CLMLR.getStrip(Template tem,
FloatImage fimg,
java.awt.Rectangle rect,
int minOffset,
int maxOffset)
Gets the patches from all points arranged in a strip |
FloatImage[] |
CLMSVM.getStrip(Template tem,
FloatImage fimg,
java.awt.Rectangle rect,
int minOffset,
int maxOffset)
Gets the patches from all points arranged in a strip |
void |
FBOwarp.grab(javax.media.opengl.GL gl,
FloatImage[] result)
Grab the result to the supplied array of float images |
void |
OpenGLwarp.grab(javax.media.opengl.GL gl,
FloatImage[] result)
Grab the frame buffer into the FloatImage |
FloatImage |
CLM.project(FloatImage strip)
Projects the sampled patches into the patch model space |
void |
AAM.projectOut(FloatImage[] diffImg,
PCI pci,
FloatImage mask)
Projects the appearance variation out the derivative image |
void |
AAM.projectOut(FloatImage[] diffImg,
PCI pci,
FloatImage mask)
Projects the appearance variation out the derivative image |
void |
GLAAM.projectOut(FloatImage[] diffImg,
PCI pci,
FloatImage mask)
Projects the appearance variation out the derivative image |
void |
GLAAM.projectOut(FloatImage[] diffImg,
PCI pci,
FloatImage mask)
Projects the appearance variation out the derivative image |
static java.awt.image.BufferedImage |
FBOwarp.setAlpha(java.awt.image.BufferedImage bimg,
FloatImage alpha)
sets the alpha channel of the image |
static java.awt.image.BufferedImage |
OpenGLwarp.setAlpha(java.awt.image.BufferedImage bimg,
FloatImage alpha)
Set the alpha channel |
static void |
GLAAM.writeImage(FloatImage[] img,
float shift,
float scale,
java.lang.String outFileName)
Writes the FloatImage to a file |
| Uses of FloatImage in Facemorph.mdl |
|---|
| Methods in Facemorph.mdl that return FloatImage | |
|---|---|
FloatImage[] |
SpecificityCombinedTest.makeRandom(int comps)
|
FloatImage[] |
SpecificityCombinedTestFile.makeRandom(int comps)
|
FloatImage[] |
SpecificityImageTest.makeRandom(int comps)
|
| Methods in Facemorph.mdl with parameters of type FloatImage | |
|---|---|
java.util.ArrayList<FloatImage[]> |
GLGroupwiseImageRegistration.calculateDerivatives(FloatImage[] mean,
float shift)
Calculate the derivatives (x and y shift of each point) |
double |
SpecificityCombinedTest.calculateError(FloatImage[] img1,
FloatImage[] img2)
|
double |
SpecificityCombinedTest.calculateError(FloatImage[] img1,
FloatImage[] img2)
|
double |
SpecificityCombinedTestFile.calculateError(FloatImage[] img1,
FloatImage[] img2)
|
double |
SpecificityCombinedTestFile.calculateError(FloatImage[] img1,
FloatImage[] img2)
|
double |
SpecificityImageTest.calculateError(FloatImage[] img1,
FloatImage[] img2)
|
double |
SpecificityImageTest.calculateError(FloatImage[] img1,
FloatImage[] img2)
|
double |
SpecificityCombinedTest.findMinError(FloatImage[] testImg)
|
double |
SpecificityCombinedTestFile.findMinError(FloatImage[] testImg)
|
double |
SpecificityImageTest.findMinError(FloatImage[] testImg)
|
java.awt.geom.Point2D.Float |
TemplatePatchMDL.getPointUpdate(java.awt.geom.Point2D.Float sPt,
java.awt.geom.Point2D.Float tPt,
FloatImage source,
FloatImage target,
int patchSize,
int windowSize)
Search for the best match for a specific point |
void |
GLGroupwiseImageRegistration.output(FloatImage[] fimg,
java.util.Vector<java.awt.geom.Point2D.Float> pts,
java.lang.String fname)
Output image and other data drawn on it for debugging |
void |
GLGroupwiseImageRegistration.setUpWarp(FloatImage[] subject,
java.util.Vector<java.awt.geom.Point2D.Float> ptVec,
java.util.Vector<java.awt.geom.Point2D.Float> iPtVec)
Sets up the warping |
void |
GLGroupwiseImageRegistration.zNormalise(FloatImage[] img,
int smoothness)
z normalisation of image |
| Uses of FloatImage in Facemorph.multifilter |
|---|
| Methods in Facemorph.multifilter that return FloatImage | |
|---|---|
FloatImage[] |
OptFilter.getImages()
Get the images |
FloatImage |
FourierDecompose.reconstruct(java.util.ArrayList<FloatImage> responses)
Reconstruct fom a set of FloatImage responses |
| Methods in Facemorph.multifilter that return types with arguments of type FloatImage | |
|---|---|
java.util.ArrayList<FloatImage> |
FourierDecompose.analyse(FloatImage fimg)
Analyse an image using the filter bank |
java.util.ArrayList<FloatImage> |
FourierDecompose.analyseExhaustive(FloatImage fimg)
Exhaustive search for best filter components Adds components until sum squared errors is > 30000 or 1000 iterations exceeded |
| Methods in Facemorph.multifilter with parameters of type FloatImage | |
|---|---|
java.util.ArrayList<FloatImage> |
FourierDecompose.analyse(FloatImage fimg)
Analyse an image using the filter bank |
java.util.ArrayList<FloatImage> |
FourierDecompose.analyseExhaustive(FloatImage fimg)
Exhaustive search for best filter components Adds components until sum squared errors is > 30000 or 1000 iterations exceeded |
| Method parameters in Facemorph.multifilter with type arguments of type FloatImage | |
|---|---|
FloatImage |
FourierDecompose.reconstruct(java.util.ArrayList<FloatImage> responses)
Reconstruct fom a set of FloatImage responses |
| Constructors in Facemorph.multifilter with parameters of type FloatImage | |
|---|---|
MultiFilter(FloatImage input,
int levs)
Creates a new instance of MultiFilter |
|
OptFilter(FloatImage[] images)
Creates a new instance of Filter |
|
| Uses of FloatImage in Facemorph.oesf |
|---|
| Methods in Facemorph.oesf that return FloatImage | |
|---|---|
static FloatImage |
AESF.buildFilter(java.lang.String file)
Builds an AESF |
FloatImage[] |
OESF.buildFilter(java.lang.String file,
HaarReader haar,
boolean orientation,
int[] plist)
Build a set of OESF filters |
FloatImage |
OESF.buildFilter(java.lang.String file,
HaarReader haar,
int[] plist)
Build an OESF filter |
static FloatImage |
OESF.centre(FloatImage fimg)
Shift the origin to centre for easier human veiwing / interpretation |
static FloatImage |
OESF.convert(Complex[] a,
int w,
int h)
Converts an array of Complex back into a FloatImage, discarding imaginary components |
static FloatImage[] |
OESF.convertComplex(Complex[] a,
int w,
int h)
Convert a Complex array into a pair of FloatImages {real, imaginary} |
static FloatImage |
OESF.filter(FloatImage fimg,
Complex[] filt,
int[] dim)
Apply a filter to an image |
static FloatImage[] |
OESF.filterComplex(FloatImage fimg,
Complex[] filt,
int[] dim)
Filters a real image with a complex filter |
| Methods in Facemorph.oesf with parameters of type FloatImage | |
|---|---|
static FloatImage |
OESF.centre(FloatImage fimg)
Shift the origin to centre for easier human veiwing / interpretation |
static Complex[] |
OESF.convert(FloatImage fimg)
Scan converts a FloatImage to an array of Complex |
static Complex[] |
OESF.convert(FloatImage[] fimg)
Converts a pair of FloatImages {real, imaginary} into a Complex array |
static FloatImage |
OESF.filter(FloatImage fimg,
Complex[] filt,
int[] dim)
Apply a filter to an image |
static FloatImage[] |
OESF.filterComplex(FloatImage fimg,
Complex[] filt,
int[] dim)
Filters a real image with a complex filter |
static void |
OESF.preprocess(FloatImage fimg)
Preprocess the image using a log transform (y=log(1+x)), normalis mean and sd and sine window |
static void |
OESF.testFilter(java.lang.String file,
java.util.ArrayList<FloatImage> filters,
FloatImage prior,
HaarReader haar)
Test the filter |
static void |
AESF.testFilter(java.lang.String file,
FloatImage filter)
Test the filter |
static void |
OESF.testFilterComplex(java.lang.String file,
java.util.ArrayList<FloatImage[]> filters,
FloatImage prior,
HaarReader haar)
Test the complex filter |
void |
FilterSet.updateResponses(FloatImage fimg)
Update the responses to the filters fitlering this image |
| Method parameters in Facemorph.oesf with type arguments of type FloatImage | |
|---|---|
static void |
OESF.testFilter(java.lang.String file,
java.util.ArrayList<FloatImage> filters,
FloatImage prior,
HaarReader haar)
Test the filter |
| Uses of FloatImage in Facemorph.psm |
|---|
| Fields in Facemorph.psm declared as FloatImage | |
|---|---|
FloatImage |
ImagePair.probability
The probability image |
| Methods in Facemorph.psm that return FloatImage | |
|---|---|
FloatImage |
PSM.evaluateProbability(FloatImage source)
Evaluate the probability using Steerable pyramid |
FloatImage |
PSMNode.evaluateProbability(java.awt.Image img)
Evaluate the probability of this feature in the image supplied |
FloatImage |
PSM.evaluateProbability(SteerablePyramid pyr)
Evaluate the probability by recursing down and up the tree |
FloatImage |
SteerablePyramid.getLinearCombination(float[] weights,
int level)
Get a linear combination of different subbands in the same level |
FloatImage |
SteerablePyramid.getLowpass()
Get the lowpass component |
FloatImage |
DiagonalEMFeature.getProbability(int featureIndex)
|
FloatImage |
DiagonalGMMFeature.getProbability(int featureIndex)
|
FloatImage |
DiagonalGaussianFeature.getProbability(int featureIndex)
|
FloatImage |
EMFeature.getProbability(int featureIndex)
|
FloatImage |
Feature.getProbability(int featureIndex)
Get the probability image for a particular feature |
FloatImage |
OESFFeature.getProbability(int featureIndex)
|
FloatImage |
PatchFeature.getProbability(int featureIndex)
Get the feature probability |
FloatImage |
SteerablePyramid.getSubband(int i)
Get subband i |
| Methods in Facemorph.psm with parameters of type FloatImage | |
|---|---|
void |
SteerablePyramid.buildPyramid(FloatImage fimg,
java.util.ArrayList<Filter> filters,
Filter lowpassFilter,
int maxLev)
Build a pyramid from and image |
FloatImage |
PSM.evaluateProbability(FloatImage source)
Evaluate the probability using Steerable pyramid |
java.util.ArrayList<java.awt.geom.Point2D.Float> |
PSM.getFeatures(FloatImage source)
Get the feature points in the image |
| Uses of FloatImage in Facemorph.psychomorph |
|---|
| Methods in Facemorph.psychomorph that return types with arguments of type FloatImage | |
|---|---|
java.util.ArrayList<FloatImage> |
Average.getFloatImages()
Get the float image array of the intensity channel |
| Uses of FloatImage in Facemorph.tensor |
|---|
| Methods in Facemorph.tensor that return FloatImage | |
|---|---|
static FloatImage[] |
Multilinear.unvectoriseColourFloatImage(double[] rgb,
int width,
int height)
Unvectorise an image to an array of FloatImage |
| Methods in Facemorph.tensor with parameters of type FloatImage | |
|---|---|
static double[] |
Multilinear.vectoriseColourFloatImage(FloatImage[] rgb)
Vectorise 3 plane RGB image into a 1D vector |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||