| | Name | Description |
|---|
  | AbsoluteHistogram(Avl.Histogram, Avl.Histogram) |
Transforms each bin value to its absolute value.
|
| AbsoluteProfile(Avl.Profile, Optional<Avl.Range>) |
Transforms each profile value to its absolute value.
|
| AbsoluteSurface(Avl.Surface, Avl.Surface) |
Transforms Z coordinate of each surface point to its absolute value.
|
| AbsoluteValueImage(Avl.Image, Optional<Avl.Region>, Avl.Image) |
Transforms pixel values to their absolute values pixel by pixel.
|
| AccessCharacterSample(Avl.CharacterSample, string, Avl.Region) |
Provides access to internal data of the CharacterSample structure.
|
| AccessEdgeModel2(Avl.EdgeModel2, int, int, float, float, List<Avl.Path>, Avl.Rectangle2D, Avl.Point2D) |
Returns information about a model.
|
| AccessGoldenTemplate2Model(Avl.GoldenTemplate2Model, Avl.Region, int, int, int, Avl.PlainType, int) |
Returns information about a model.
|
| AccessOcrCandidate(Avl.OcrCandidate, string, float) |
Returns fields of OcrCandidate structure.
|
| AccessSpatialMap(Avl.SpatialMap, int, int, int, Avl.PlainType, int, int, int, Avl.ImageFormat, Avl.InterpolationMethod) |
Returns individual fields of a spatial map.
|
| AccumulateProfile(float, Optional<int>, bool, Avl.Profile) |
Creates a profile in a loop by concatenating individual values.
|
| AddChannels_Saturation(Avl.Image, Optional<Avl.Region>, Avl.Image) |
Creates a monochromatic image by summing the values of the input image channels
with saturation.
|
| AddChannels(Avl.Image, Optional<Avl.Region>, Avl.Image) |
Creates a monochromatic image by summing the values of the input image channels.
|
| AddHistograms_OfArray(List<Avl.Histogram>, Avl.Histogram) |
Adds histograms of an array bar by bar.
|
| AddHistograms_OfLoop(Avl.HistogramCombinators_OfLoopState, Avl.Histogram, Avl.Histogram) |
Adds histograms appearing in consecutive iterations bar by bar.
|
| AddHistograms(Avl.Histogram, Avl.Histogram, Avl.Histogram) |
Adds two histograms bar by bar.
|
| AddImages_OfArray(List<Avl.Image>, Optional<Avl.Region>, float, Avl.Image) |
Adds images of an array pixel by pixel.
|
| AddImages_OfLoop(Avl.ImageCombinators_OfLoopState, Avl.Image, Optional<Avl.Region>, float, Avl.Image) |
Adds images appearing in consecutive iterations pixel by pixel.
|
| AddImages(Avl.Image, Avl.Image, Optional<Avl.Region>, float, Avl.Image) |
Adds two images pixel by pixel.
|
| AddNoiseToImage(Avl.RandomState, Avl.Image, float, float, float, bool, Optional<int>, Avl.Image) |
Adds random noise to the image.
|
| AddProfiles_OfArray(List<Avl.Profile>, Avl.Profile) |
Adds profiles of an array value by value.
|
| AddProfiles_OfLoop(Avl.ProfileCombinators_OfLoopState, Avl.Profile, Avl.Profile) |
Adds profiles appearing in consecutive iterations value by value.
|
| AddProfiles(Avl.Profile, Avl.Profile, Avl.Profile) |
Adds two profiles value by value.
|
| AddSpatialMaps(Avl.SpatialMap, Avl.SpatialMap, Avl.SpatialMap) |
Combines two spatial maps.
|
| AddToHistogram(Avl.Histogram, double, Avl.Histogram) |
Increases each bin value by a number.
|
| AddToImage(Avl.Image, Optional<Avl.Region>, float, Avl.Image) |
Adds a scalar value to each pixel.
|
| AddToProfile(Avl.Profile, Optional<Avl.Range>, float) |
Adds a scalar value to each element of a profile.
|
| AdjustPathArraysToEdges(Avl.Image, List<List<Avl.Path>>, Optional<float>, Optional<List<Avl.CoordinateSystem2D>>, float, Avl.AdjustmentMetric, bool, bool, bool, int, float, List<List<Avl.Path>>, List<Avl.CoordinateSystem2D>, Diagnostic<List<List<Avl.Segment2D>>>) |
Translates, rotates and scales multiple contour sets (PathArray), each separately,
to the edges of the input image with subpixel precision.
|
| AdjustPathArrayToEdges(Avl.Image, List<Avl.Path>, Optional<float>, Optional<Avl.CoordinateSystem2D>, float, Avl.AdjustmentMetric, bool, bool, bool, int, float, List<Avl.Path>, Avl.CoordinateSystem2D, Diagnostic<List<Avl.Segment2D>>) |
Translates, rotates and scales the given contour set to the edges of the input
image with subpixel precision.
|
| AdjustPointArrays(List<Avl.Point2D>, List<Avl.Point2D>, bool, bool, int, float, int, Conditional<List<Avl.Point2D>>, Conditional<Avl.CoordinateSystem2D>) |
Aligns a point array to match best the input point array.
|
| AdjustPointGrids3DGlobal(Avl.Point3DGrid, Avl.Point3DGrid, int, float, float, Optional<Avl.TransformLimits3D>, Optional<float>, Optional<int>, Avl.Point3DGrid, Avl.Matrix, float) |
Aligns (rotation + translation) a point grid to match best the reference point
grid using a global registration algorithm.
|
| AdjustPointGrids3D(Avl.Point3DGrid, Avl.Point3DGrid, int, float, float, Avl.Point3DGrid, Avl.Matrix, Diagnostic<List<Avl.Point3D>>, Diagnostic<List<Avl.Point3D>>, Diagnostic<List<List<Avl.Segment3D>>>) |
Aligns (rotation + translation) a point grid to match best the reference point
grid.
|
| AlignArc(Avl.Arc2D, Avl.CoordinateSystem2D, bool, Avl.Arc2D) |
Moves an arc from a local coordinate system to the absolute one.
|
| AlignCircle(Avl.Circle2D, Avl.CoordinateSystem2D, bool, Avl.Circle2D) |
Moves a circle from a local coordinate system to the absolute one.
|
| AlignCoordinateSystem(Avl.CoordinateSystem2D, Avl.CoordinateSystem2D, bool, Avl.CoordinateSystem2D) |
Moves a nested coordinate system from its local coordinate system to the absolute
one.
|
| AlignLine(Avl.Line2D, Avl.CoordinateSystem2D, bool, Avl.Line2D) |
Moves a line from a local coordinate system to the absolute one.
|
| AlignPathArray(List<Avl.Path>, Avl.CoordinateSystem2D, bool, List<Avl.Path>) |
Moves an array of paths from a local coordinate system to the absolute one.
|
| AlignPath(Avl.Path, Avl.CoordinateSystem2D, bool, Avl.Path) |
Moves a path from a local coordinate system to the absolute one.
|
| AlignPoint3DArrayToPlane(List<Avl.Point3D>, Avl.Plane3D, List<Avl.Point3D>, Optional<Avl.Matrix>, Optional<Avl.Matrix>) |
Rotates an array of 3D points with a rotation that transforms the input plane
to be parallel to XY plane.
|
| AlignPoint3DGridToPlane(Avl.Point3DGrid, Avl.Plane3D, Avl.Point3DGrid, Optional<Avl.Matrix>, Optional<Avl.Matrix>) |
Rotates a grid of 3D points with a rotation that transforms the input plane
to be parallel to XY plane.
|
| AlignPointArray(List<Avl.Point2D>, Avl.CoordinateSystem2D, bool, List<Avl.Point2D>) |
Moves an array of points from a local coordinate system to the absolute one.
|
| AlignPoint(Avl.Point2D, Avl.CoordinateSystem2D, bool, Avl.Point2D) |
Moves a point from a local coordinate system to the absolute one.
|
| AlignRectangle(Avl.Rectangle2D, Avl.CoordinateSystem2D, bool, Avl.Rectangle2D) |
Moves a rectangle from a local coordinate system to the absolute one.
|
| AlignRegionToSurfaceCoordinatesFormat(Avl.Region, Avl.SurfaceCoordinatesFormat, Avl.SurfaceCoordinatesFormat, Optional<int>, Optional<int>, Avl.Region) |
Returns region covering the same area for the surface with another coordinates
format.
|
| AlignRegionToSurfaceFormat(Avl.Region, Avl.SurfaceCoordinatesFormat, Avl.SurfaceFormat, Avl.Region) |
Returns region covering the same area for the surface with another format.
|
| AlignRegion(Avl.Region, Avl.CoordinateSystem2D, bool, Optional<int>, Optional<int>, Avl.Region) |
Aligns a region to a coordinate system.
|
| AlignSegment(Avl.Segment2D, Avl.CoordinateSystem2D, bool, Avl.Segment2D) |
Moves a segment from a local coordinate system to the absolute one.
|
| AlignShapeRegion(Avl.ShapeRegion, Avl.CoordinateSystem2D, bool, Optional<int>, Optional<int>, Avl.ShapeRegion) |
Aligns a shape region to a coordinate system.
|
| AnalyzePoint3DGrid(Avl.Point3DGrid, Avl.Point3DGridType, Avl.ValueLimits, Avl.ValueLimits, Avl.ValueLimits, float, float, float, double, double, double, double) |
Analyzes the steps in X and Y directions of a point 3D grid.
|
| angleAvg(float, float, float) | |
| AngleBetweenDirections(float, float, Optional<Avl.RotationDirection>, Avl.AngleRange, Optional<float>, Optional<float>) |
Measures the rotation angle from first to second direction.
|
| AngleBetweenLines3D(Avl.Line3D, Avl.Line3D, Optional<float>, Optional<float>) |
Measures the smaller and the larger angle between two lines in 3D.
|
| AngleBetweenLines(Avl.Line2D, Avl.Line2D, Optional<float>, Optional<float>) |
Measures the smaller and the larger angle between two lines.
|
| AngleBetweenPlanes(Avl.Plane3D, Avl.Plane3D, Optional<float>, Optional<float>) |
Measures the smaller and the larger angle between two planes in 3D.
|
| AngleBetweenSegments3D(Avl.Segment3D, Avl.Segment3D, float) |
Measures the angle between two segments in 3D.
|
| AngleBetweenSegments(Avl.Segment2D, Avl.Segment2D, Avl.AngleMetric, bool, Optional<float>, Optional<float>, Optional<Avl.Arc2D>) |
Measures the angle between two segments with one of four possible metrics.
|
| AngleBetweenThreePoints3D(Avl.Point3D, Avl.Point3D, Avl.Point3D, float) |
Measures the angle defined by three consecutive points in 3D.
|
| AngleBetweenThreePoints(Avl.Point2D, Avl.Point2D, Avl.Point2D, Avl.RotationDirection, Optional<float>, Optional<float>, Optional<Avl.Arc2D>) |
Measures the angle defined by three consecutive points.
|
| AngleBetweenVectors3D(Avl.Vector3D, Avl.Vector3D, float) |
Measures the angle between two vectors in 3D.
|
| AngleBetweenVectors(Avl.Vector2D, Avl.Vector2D, Optional<Avl.RotationDirection>, Optional<float>, Optional<float>) |
Measures the angle between two vectors.
|
| angleDiff(float, float, float) | |
| angleNorm(float, float) | |
| angleTurn(float, float, float) | |
| AnnotateGridPoints_DeprecatedDeprecated(List<Avl.Point2D>, float, Optional<float>, float, float, List<Avl.Point3D>, List<Avl.Point2D>, Diagnostic<List<Avl.Segment2D>>) | |
| AnnotateGridPoints_Ransac(List<Avl.Point2D>, Optional<int>, Optional<int>, float, Optional<float>, float, float, float, Optional<float>, Optional<float>, Optional<float>, List<Avl.AnnotatedPoint2D>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<float>) |
Select a subset of the given points that forms a grid and assign 2D indices
to them.
|
| AnnotateGridPoints(List<Avl.Point2D>, Optional<float>, Optional<float>, float, List<Avl.AnnotatedPoint2D>, Diagnostic<List<Avl.Segment2D>>) |
Select a subset of the given points that forms a grid and assign 2D indices
to them.
|
| AnyCameraModelToRectificationTransform(Avl.AnyCameraModel, Avl.RectificationTransform) |
Conversion
|
| AppendImageChannel(Avl.Image, float, Avl.Image) |
Appends a single valued channel to the input image.
|
| AppendPointToPath(Avl.Path, Avl.Point2D) |
Appends a point to a path.
|
| ApplyPCATransform(Avl.Matrix, Avl.PCAModel, Avl.Matrix) |
Applies previously obtained Principal Component Analysis (PCA) transformation
coefficients to new data.
|
| ApplyPixelLut(Avl.Image, Optional<Avl.Region>, Avl.PixelLut, Avl.Image) |
Applies previously created Look Up transformation to provided image.
|
| ArcCircle(Avl.Arc2D, Avl.Circle2D) |
Computes the circle containing an arc.
|
| ArcEndpoints(Avl.Arc2D, Avl.Point2D, Avl.Point2D) |
Computes two endpoints of an arc.
|
| ArcLength(Avl.Arc2D, float) |
Computes the length of an arc.
|
| ArcMidpoint(Avl.Arc2D, Avl.Point2D) |
Computes the midpoint of an arc.
|
| ArrangePoint3DArray(List<Avl.Point3D>, Avl.ValueLimits_f64, double, Avl.ValueLimits_f64, double, Avl.ValueLimits_f64, double, double, Avl.PlainType, Avl.SurfaceMultipointHeight, Avl.Surface, Optional<double>, Optional<double>, Diagnostic<Avl.Region>) |
Creates a surface structure from Point3D array taking into account X and Y coordinates.
|
| ArrangePoint3DGrid(Avl.Point3DGrid, Avl.ValueLimits_f64, double, Avl.ValueLimits_f64, double, Avl.ValueLimits_f64, double, double, Avl.PlainType, Avl.SurfaceMultipointHeight, Avl.Surface, Optional<double>, Optional<double>, Diagnostic<Avl.Region>) |
Creates a surface structure from Point3DGrid taking into account X and Y coordinates.
|
| AssertImageEqualTo(Avl.Image, Avl.Image, float, string, float, int) |
Asserts that two images are equal or differ by a small given margin.
|
| AutoAdjustColors(Avl.Image, Avl.Image) |
Adjusts image colors by stretching each channel separately.
|
| AverageAngle(List<float>, Avl.AngleRange, float) |
Computes the average of the input angles using points on a unit circle.
|
| AverageChannels_121(Avl.Image, Optional<Avl.Region>, Avl.Image) |
Creates a monochromatic image by averaging the input image channels.
|
| AverageChannels_251(Avl.Image, Optional<Avl.Region>, Avl.Image) |
Creates a monochromatic image by averaging the input image channels.
|
| AverageChannels_Weighted(Avl.Image, Optional<Avl.Region>, int, int, int, int, Avl.Image) |
Creates a monochromatic image from weighted averages of the input image channels.
|
| AverageChannels(Avl.Image, Optional<Avl.Region>, Avl.Image) |
Creates a monochromatic image by averaging the input image channels.
|
| AverageImages_OfArray(List<Avl.Image>, Optional<Avl.Region>, Avl.Image) |
Averages images from an array pixel by pixel.
|
| AverageImages_OfLoop(Avl.AverageImages_OfLoopState, Avl.Image, Optional<Avl.Region>, Optional<Avl.Image>) |
Averages images appearing in consecutive iterations pixel by pixel.
|
| AverageImages(Avl.Image, Avl.Image, Optional<Avl.Region>, Avl.Image) |
Averages two images pixel by pixel.
|
| AveragePath(Avl.Path, Avl.Path, Avl.Path) |
Computes the average of two paths (of equal size and type) point by point.
|
| AveragePoint(Avl.Point2D, Avl.Point2D, Avl.Point2D) |
Computes the middle point of two input points.
|
| average(Avl.Point2D, Avl.Point2D) | |
| AvlAlloc(ulong) | |
| AvlDbgAlloc(ulong, string, int) | |
| AvlFree(System.IntPtr) | |
| BarcodeFormatToMIL1DcodeFormat(Avl.BarcodeFormat, Avl.MIL1DcodeFormat) |
Converts BarcodeFormat object to a MIL1DcodeFormat
|
| BayerToRgb(Avl.Image, Avl.DebayeringMethod, Avl.BayerType, Avl.Image) |
Converts a Bayer-encoded color image into RGB color space.
|
| BeginOAuthAuthorization(Avl.OAuthProvider, Conditional<string>, Conditional<string>, Diagnostic<Conditional<string>>) |
Begins the OAuth 2.0 device authorization flow.
|
| begin(Avl.Point3DGrid) | |
| BlendImages(Avl.Image, Avl.Image, Optional<Avl.Region>, float, float, Avl.Image) |
Computes weighted sum pixel by pixel.
|
| BoolToHash(bool, Avl.Hash) |
Converts a Bool to a Hash.
|
| BoolToPassFailStatus(bool, bool) |
Converts a bool value to a pass/fail status.
|
| BottomHatImage_AnyKernel(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, Optional<Avl.Pixel>, Avl.Region, Optional<Avl.Location>, Avl.Image) |
Performs a morphological black top hat (bottom hat) operation on a image using
an arbitrary kernel.
|
| BottomHatImage_Mask(Avl.Image, Optional<Avl.Region>, Optional<Avl.Pixel>, Avl.MorphologyKernel, Avl.Image) |
Performs a morphological black top hat (bottom hat) operation on a image using
a predefined mask.
|
| BottomHatImage(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, Optional<Avl.Pixel>, Avl.KernelShape, int, Optional<int>, Avl.Image, Diagnostic<Avl.Region>) |
Performs a morphological black top hat (bottom hat) operation on a image using
a predefined kernel.
|
| BottomHatRegion_AnyKernel(Avl.Region, Avl.Region, Avl.Region) |
Performs a morphological black top hat (bottom hat) operation on a region using
an arbitrary kernel.
|
| BottomHatRegion(Avl.Region, Avl.KernelShape, int, Optional<int>, Avl.Region) |
Performs a morphological black top hat (bottom hat) operation on a region using
a predefined kernel.
|
| Box2DToBox3D_AxesPlane(Avl.Box, Avl.PlaneType, float, Avl.Box3D, Optional<Avl.Plane3D>) |
Projects a 2D box onto a plane defined by 3D coordinate axes.
|
| Box3DCenter(Avl.Box3D, Avl.Point3D) |
Returns the center of the input box in 3D.
|
| Box3DCharacteristicPoint(Avl.Box3D, Avl.Anchor3D, Avl.Point3D) |
Returns a characteristic point of a box in 3D.
|
| Box3DSurfaceArea(Avl.Box3D, float) |
Returns the surface area of the input box in 3D.
|
| Box3DToBox2D_AxesPlane(Avl.Box3D, Avl.PlaneType, Avl.Box, Optional<Avl.Rectangle2D>, Optional<Avl.Plane3D>) |
Projects a 3D box onto a plane defined by coordinate axes.
|
| Box3DToBox(Avl.Box3D, Avl.Box) |
Converts a box in 3D to a box in 2D by ignoring its Z coordinates.
|
| Box3DVolume(Avl.Box3D, float) |
Returns the volume of the input box in 3D.
|
| BoxCenter(Avl.Box, Avl.Point2D) |
Returns center of a box.
|
| BoxCharacteristicPoints(Avl.Box, Optional<Avl.Point2D>, Optional<Avl.Point2D>, Optional<Avl.Point2D>, Optional<Avl.Point2D>, Optional<Avl.Point2D>, Optional<Avl.Point2D>, Optional<Avl.Point2D>, Optional<Avl.Point2D>, Optional<Avl.Point2D>, Optional<List<Avl.Point2D>>) |
Computes the characteristic points of the box.
|
| BoxCharacteristicPoint(Avl.Box, Avl.Anchor2D, Avl.Point2D) |
Returns a characteristic point (e.g. the top-left) of a box.
|
| Boxes3DBoundingBox3D_OrNil(List<Avl.Box3D>, Conditional<Avl.Box3D>) |
Computes the bounding box 3D of given boxes in 3D; returns NIL if the array
is empty.
|
| BoxesBoundingBox3D(List<Avl.Box3D>, Avl.Box3D) |
Computes the bounding box 3D of given boxes in 3D.
|
| BoxesBoundingBox_OrNil(List<Avl.Box>, Conditional<Avl.Box>) |
Computes the bounding box of given boxes; returns NIL if the array is empty.
|
| BoxesBoundingBox(List<Avl.Box>, Avl.Box) |
Computes the bounding box of given boxes.
|
| BoxIntersection3D(Avl.Box3D, Avl.Box3D, Avl.Box3D) |
Computes the common part of two boxes in 3D.
|
| BoxIntersection(Avl.Box, Avl.Box, Avl.Box) |
Computes the common part of two boxes.
|
| BoxToBox3D(Avl.Box, Avl.Box3D) |
Converts a box in 2D to a box in 3D.
|
| BoxToBoxDistance(Avl.Box, Avl.Box, float, float, Optional<Avl.Segment2D>) |
Computes minimal distance between one of the points of the first box with one
of the points of the second box.
|
| BoxToRectangle2D(Avl.Box, Avl.Rectangle2D) |
Converts a box to a rectangle.
|
| BoxToShapeRegionDeprecated(Avl.Box, Avl.ShapeRegionDeprecated) | |
| BoxToShapeRegion(Avl.Box, Avl.ShapeRegion) |
Converts a box to shape region.
|
| CalibrateCamera_LineScan(List<Avl.AnnotatedPoint2D>, float, int, Avl.LensDistortionModelType, float, Optional<float>, Avl.LineScanCameraModel, float, Optional<float>, Optional<float>, Optional<List<Avl.Segment2D>>) |
Finds the line scan camera intrinsic parameters from calibration grid.
|
| CalibrateCamera_Pinhole(List<List<Avl.AnnotatedPoint2D>>, int, int, Avl.LensDistortionModelType, float, Optional<float>, Avl.PinholeCameraModel, Optional<Avl.PinholeCameraModel>, Optional<float>, Optional<List<float>>, Optional<List<List<Avl.Segment2D>>>) |
Finds the camera intrinsic parameters from calibration grids. Uses pinhole camera
model (perspective camera).
|
| CalibrateCamera_Telecentric(List<List<Avl.AnnotatedPoint2D>>, float, int, int, Avl.LensDistortionModelType, float, Avl.TelecentricCameraModel, Optional<Avl.TelecentricCameraModel>, Optional<float>, Optional<List<float>>, Optional<List<List<Avl.Segment2D>>>) |
Finds the telecentric camera intrinsic parameters from calibration grids.
|
| CalibrateEyeInHandDataPrep(List<Avl.Image>, List<Avl.Point3DGrid>, Optional<float>, Avl.Size, List<Avl.Matrix>, List<Avl.Matrix>, List<bool>, Diagnostic<List<Avl.Image>>, Diagnostic<List<Avl.Point3DGrid>>, Diagnostic<List<Avl.Point3DGrid>>) |
Compute the transformation between the camera and the calibration target reference
frames. (all units in mm)
|
| CalibrateEyeInHand(List<Avl.Matrix>, List<Avl.Matrix>, List<Avl.Matrix>, List<Avl.Matrix>, Avl.HandEyeCalibrationMethod, Avl.Matrix, Avl.Matrix) |
Computes Hand-Eye calibration matrices.
|
| CalibrateWorldPlane_Default(List<Avl.AnnotatedPoint2D>, Optional<Avl.AnyCameraModel>, float, float, Avl.RectificationTransform, Optional<float>, Optional<float>, Optional<List<Avl.Segment2D>>) |
Finds the image to world plane transformation parameters from world plane calibration
grid. World plane origin and axes are unspecified.
|
| CalibrateWorldPlane_Labeled(List<Avl.AnnotatedPoint2D>, List<Avl.AnnotatedPoint2D>, Optional<Avl.AnyCameraModel>, Optional<float>, float, bool, Avl.RectificationTransform, Optional<List<Avl.AnnotatedPoint2D>>, Optional<Conditional<float>>, Optional<float>, Optional<float>, Optional<float>, Optional<List<Avl.Segment2D>>) |
Finds the image to world plane transformation parameters using sparse world
coordinate information, i.e. world coordinates are known for only a few points
of the grid.
|
| CalibrateWorldPlane_Manual(List<Avl.Point2D>, List<Avl.Point2D>, Optional<Avl.AnyCameraModel>, float, Avl.RectificationTransform, Optional<float>, Optional<float>, Optional<List<Avl.Segment2D>>) |
Finds the image to world plane transformation parameters. Image and their corresponding
world points are directly specified (no grid needed).
|
| CalibrateWorldPlane_Multigrid(List<List<Avl.AnnotatedPoint2D>>, List<List<Avl.AnnotatedPoint2D>>, Optional<Avl.AnyCameraModel>, Optional<float>, float, bool, Avl.RectificationTransform, Optional<List<List<Avl.AnnotatedPoint2D>>>, Optional<Conditional<float>>, Optional<float>, Optional<float>, Optional<List<float>>, Optional<List<List<Avl.Segment2D>>>, Optional<List<float>>, Optional<List<Avl.Vector2D>>) |
Finds the image to world plane transformation parameters using multiple grids,
using sparse world coordinate information.
|
| CalibrateWorldPlane_OffgridOrigin(List<Avl.AnnotatedPoint2D>, Optional<Avl.AnyCameraModel>, float, float, Optional<Avl.Point2D>, Optional<Avl.Point2D>, Avl.RectificationTransform, Optional<float>, Optional<float>, Optional<List<Avl.Segment2D>>) |
Finds the image to world plane transformation matrix, with world origin and
axes specified in the image coordinates.
|
| CancelCurrentWork() | |
| ChargeImageMemoryPools(List<int>, bool) |
Preallocates memory buffers for images.
|
| CheckLicense(Avl.ProductType, bool) |
Check license for a specified module.
|
| CheckPresence_EdgeAmount(Avl.Image, Avl.ShapeRegion, Optional<Avl.CoordinateSystem2D>, Avl.GradientMaskOperator, Avl.MagnitudeMeasure, int, int, float, float, bool, Optional<float>, Optional<Avl.Region>, Optional<Avl.ShapeRegion>) |
Verifies object presence by analysing the amount of edges in the specified region.
|
| CheckPresence_Intensity(Avl.Image, Avl.ShapeRegion, Optional<Avl.CoordinateSystem2D>, Optional<float>, Optional<float>, float, Optional<float>, bool, Optional<float>, Optional<float>, Optional<Avl.ShapeRegion>) |
Verifies object presence by analysing pixel intensities in the specified region.
|
| CheckPresence_PixelAmount(Avl.Image, Avl.ShapeRegion, Optional<Avl.CoordinateSystem2D>, Avl.HSxColorModel, int, int, int, Optional<int>, Optional<float>, Optional<float>, float, float, bool, Optional<float>, Optional<Avl.Region>, Optional<Avl.ShapeRegion>, Diagnostic<Avl.Image>) |
Verifies object presence by analysing the amount of pixels that meet the specified
criteria.
|
| Circle2DToCircle3D_AxesPlane(Avl.Circle2D, Avl.PlaneType, float, Avl.Circle3D, Optional<Avl.Plane3D>) |
Projects a 2D circle onto a plane defined by 3D coordinate axes.
|
| Circle2DToCircle3D(Avl.Circle2D, Avl.Circle3D) |
Converts a circle in 2D to a circle in 3D.
|
| Circle2DToEllipse2D(Avl.Circle2D, Avl.Ellipse2D) |
Converts a circle to an ellipse.
|
| Circle2DToRing2D(Avl.Circle2D, Avl.Ring2D) |
Converts a circle to a full circle ring.
|
| Circle2DToShapeRegionDeprecated(Avl.Circle2D, Avl.ShapeRegionDeprecated) | |
| Circle2DToShapeRegion(Avl.Circle2D, Avl.ShapeRegion) |
Converts a circle to region of interest.
|
| Circle3DArea(Avl.Circle3D, float) |
Computes the area of a circle in 3D.
|
| Circle3DBoundingBox(Avl.Circle3D, Avl.Box3D) |
Computes the smallest box in 3D containing a circle in 3D.
|
| Circle3DPerimeterLength(Avl.Circle3D, float) |
Computes the length of a circle in 3D perimeter.
|
| Circle3DToCircle2D_AxesPlane(Avl.Circle3D, Avl.PlaneType, Avl.Circle2D, Optional<Avl.Plane3D>) |
Projects a 3D circle onto a plane defined by coordinate axes.
|
| Circle3DToCircle2D(Avl.Circle3D, Avl.Circle2D) |
Converts a circle in 3D to a circle in 2D by ignoring its Z coordinates and
tilt.
|
| CircleArea(Avl.Circle2D, float) |
Computes the area of a circle.
|
| CircleBoundingBox(Avl.Circle2D, Avl.Box) |
Computes the smallest box containing a circle.
|
| CircleBoundingRectangle(Avl.Circle2D, Optional<float>, Avl.Rectangle2D, Optional<Avl.Point2D>, Optional<float>, Optional<float>) |
Computes the smallest rectangle containing a circle.
|
| CircleCharacteristicPoint(Avl.Circle2D, Avl.Anchor2D, Avl.Point2D) |
Returns a characteristic point (e.g. the top-left) of a box containing the input
circle.
|
| CircleCircleIntersection(Avl.Circle2D, Avl.Circle2D, Conditional<Avl.Point2D>, Conditional<Avl.Point2D>) |
Computes common points of two circles.
|
| CirclePerimeterLength(Avl.Circle2D, float) |
Computes the length of a circle perimeter.
|
| CirclePlaneIntersection3D(Avl.Circle3D, Avl.Plane3D, Conditional<Avl.Point3D>, Conditional<Avl.Point3D>) |
Computes common points of a circle in 3D and a plane.
|
| CircleSection(Avl.Circle2D, float, float, Avl.Arc2D) |
Computes an arciform section of the circle perimeter.
|
| CircleTangents(Avl.Circle2D, Avl.Point2D, Conditional<Avl.Line2D>, Conditional<Avl.Line2D>) |
Computes circle tangent lines passing through a point.
|
| CircleThroughPoints3D(Avl.Point3D, Avl.Point3D, Avl.Point3D, Conditional<Avl.Circle3D>) |
Computes a circle in 3D passing through three noncollinear 3D points.
|
| CircleThroughPoints(Avl.Point2D, Avl.Point2D, Avl.Point2D, Conditional<Avl.Circle2D>) |
Computes a circle passing through three noncollinear points.
|
| CircleToCircleDistance(Avl.Circle2D, Avl.Circle2D, float, float, Optional<Avl.Segment2D>) |
Measures the distance between two circles.
|
| CircleToPlaneDistance3D(Avl.Circle3D, Avl.Plane3D, float, float, Optional<Avl.Segment3D>, Optional<float>) |
Measures the distance between a circle in 3D and a plane.
|
| ClassifyPaths(List<Avl.Path>, Avl.PathFilter, Avl.PathFeature, Optional<float>, Optional<float>, Optional<List<Avl.Path>>, Optional<List<Avl.Path>>, Optional<List<Avl.Path>>, Optional<List<Avl.Path>>, Optional<List<float>>) |
Splits the paths of the input array - in accordance to the relation between
computed feature values and the specified range.
|
| ClassifyRegions(List<Avl.Region>, Avl.RegionFeature, Optional<float>, Optional<float>, Optional<List<Avl.Region>>, Optional<List<Avl.Region>>, Optional<List<Avl.Region>>, Optional<List<Avl.Region>>, Optional<List<float>>) |
Splits an array of regions according to the selected feature and range.
|
| ClearImage(Avl.Image, Optional<Avl.Region>, Avl.Pixel) |
Sets image pixels in ROI to the specified value.
|
| ClipPixels(Avl.Image, Optional<Avl.Region>, Optional<float>, Optional<float>, Avl.Image) |
Sets pixels below the low value to the low value and above the high value to
the high value.
|
| ClipProfileValues(Avl.Profile, Optional<Avl.Range>, Optional<float>, Optional<float>) |
Applies limits to profile values.
|
| CloseGPUProcessing() | |
| CloseImage_AnyKernel(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, Optional<Avl.Pixel>, Avl.Region, Optional<Avl.Location>, Avl.Image) |
Removes small dark structures from an image (or fills in bright ones) by applying
consecutive dilation and erosion.
|
| CloseImage_Mask(Avl.Image, Optional<Avl.Region>, Optional<Avl.Pixel>, Avl.MorphologyKernel, Avl.Image) |
Removes small dark structures from an image (or fills in bright ones) by applying
consecutive dilation and erosion.
|
| CloseImage(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, Optional<Avl.Pixel>, Avl.KernelShape, int, Optional<int>, Avl.Image, Diagnostic<Avl.Region>) |
Removes small dark structures from an image (or fills in bright ones) by applying
consecutive dilation and erosion.
|
| ClosePath(Avl.Path) |
Adds the segment connecting the last point with the first one in a path.
|
| CloseRegion_AnyKernel(Avl.Region, Avl.Region, Avl.Region) |
Performs a morphological closing on a region using an arbitrary kernel.
|
| CloseRegion(Avl.Region, Avl.KernelShape, int, Optional<int>, Avl.Region) |
Performs a morphological closing on a region using selected predefined kernel.
|
| CloseSurfacePoints(Avl.Surface, Optional<Avl.Region>, Avl.KernelShape, int, Optional<int>, Avl.Surface) |
Reconstructs missing points of the input surface by interpolating neighboring
points.
|
| ClusterData_KMeans(List<List<float>>, int, int, int, float, Avl.KMeansClusteringMethod, Avl.Matrix, List<int>, float) |
Clusters data using KMeans algorithm.
|
| ClusterPoints2D_SingleLink(List<Avl.Point2D>, Optional<int>, Optional<float>, List<List<Avl.Point2D>>) |
Clusters data using hierarchical single-link algorithm.
|
| ClusterPoints2D(List<Avl.Point2D>, int, int, Optional<int>, int, List<Conditional<List<Avl.Point2D>>>, List<Conditional<Avl.Point2D>>, float) |
Clusters 2D points using K Means Clustering method.
|
| ClusterPoints3D(List<Avl.Point3D>, int, int, Optional<int>, int, List<Conditional<List<Avl.Point3D>>>, List<Conditional<Avl.Point3D>>, float) |
Clusters 3D points using K Means Clustering method.
|
| CmykToRgb(Avl.Image, Avl.Image) |
Converts color space from Cyan-Magenta-Yellow-Key into Red-Green-Blue.
|
| ColorDistanceImage(Avl.Image, Optional<Avl.Region>, Avl.Pixel, float, Avl.Image) |
Compares each pixel with the specified color using chromatic and non-chromatic
information.
|
| ColorDistance_CIE76(Avl.Pixel, Avl.Pixel, float) |
Compares two pixels using CIE76 delta E. Assumes RGB color space.
|
| ColorDistance_CIE94(Avl.Pixel, Avl.Pixel, float, float, float, float, float, float) |
Compares two pixels using CIE94 delta E. Assumes RGB color space.
|
| ColorDistance_CIEDE2000(Avl.Pixel, Avl.Pixel, float, float, float, float) |
Compares two pixels using CIEDE2000 delta E. Assumes RGB color space.
|
| ColorDistance(Avl.Pixel, Avl.Pixel, float, float) |
Compares two pixels using chromatic and non-chromatic information. Assumes RGB
color space.
|
| ColorizeImage(Avl.ColorizeImageState, Avl.Image, Optional<Avl.Region>, Avl.ColorPalette, bool, Optional<int>, Optional<int>, Avl.Image, Diagnostic<Avl.Image>) |
Shows a monochromatic image in false colors.
|
| CombineSpatialMaps(Avl.SpatialMap, Avl.SpatialMap, Avl.SpatialMap) |
Combines two spatial maps.
|
| CompareGoldenTemplate2(Avl.Image, Avl.GoldenTemplate2Model, float, float, Avl.Region) |
Compares an image with a multi-image model using an ensemble of image features
approach.
|
| CompareGoldenTemplate_Edges(Avl.Image, Avl.EdgeGoldenTemplate, Avl.CoordinateSystem2D, float, Optional<float>, float, float, int, Avl.Region, bool, Avl.Region, Avl.Region, Optional<Avl.Region>, Optional<Avl.Region>, Optional<Avl.Region>, Optional<Avl.Rectangle2D>) |
Compares image edges with the edges of a perfect template. Significant differences
are considered defects.
|
| CompareGoldenTemplate_Intensity(Avl.Image, Avl.GrayGoldenTemplate, Optional<Avl.CoordinateSystem2D>, float, int, Avl.Region, Avl.Region, bool, Avl.Region, Optional<Avl.Rectangle2D>) |
Compares an image with a template image considered to have no defects.
|
| CompareImages_CVG(Avl.Image, Avl.Image, float, float, float, Avl.Image) |
Compares two images tile by tile using one of several available methods.
|
| CompareImages(Avl.Image, Avl.Image, Avl.CompareMeasure, int, int, Avl.Image) |
Compares two images tile by tile using one of several available methods.
|
| ComposeImages(Avl.Image, Avl.Image, Avl.Region, Optional<Avl.Region>, Avl.Image) |
Takes pixels from the first image within the specified region and from the other
one elsewhere.
|
| ConcatenatePaths_OfArray(List<Avl.Path>, bool, Avl.Path) |
Joins open paths of an array.
|
| ConcatenatePaths_OfLoop(Avl.ConcatenatePaths_OfLoopState, Avl.Path, bool, Avl.Path) |
Joins open paths appearing in consecutive iterations.
|
| ConcatenatePaths(Avl.Path, Avl.Path, Avl.Path, Avl.Path, bool, Avl.Path) |
Joins up to four open paths.
|
| ControlAVX2(bool, bool) |
Enables or disables AVX2 cpu extension usage by other filters.
|
| ControlEdgeModelLimits(Optional<int>, Optional<int>, bool) |
Limits the size of the EdgeModel objects created by CreateEdgeModel filter.
|
| ControlImageMemoryPools(bool) |
Enables or disables deterministic image memory allocator.
|
| ControlParallelComputing(bool, Optional<int>, Optional<int>, int) |
Enables or disables filters multithreading parallelization.
|
| ControlSIMD(Optional<Avl.SimdLevel>, Avl.SimdLevel) |
Enables or disables SIMD cpu extension (e.g. SSE, AVX2, NEON) usage by other
filters. This filter does not affect third party components e.g. camera software,
OpenCV.
|
| ControlSSE(bool, bool) |
Enables or disables SSE cpu extension usage by other filters.
|
| ConvertCoordinateSystem2DTo3D(Avl.CoordinateSystem2D, Avl.SurfaceFormat, Avl.CoordinateSystem2D) |
Converts a coordinate system connected with the surface image to a coordinate
system connected with the surface.
|
| ConvertMatrixMapsToSpatialMap(Avl.ImageFormat, Avl.Matrix, Avl.Matrix, Avl.InterpolationMethod, bool, Avl.SpatialMap, Optional<Avl.Region>) |
Joins two matrices of coordinates to produce a SpatialMap for use in RemapImage.
|
| ConvertPixelType(Avl.Image, Optional<Avl.Region>, Avl.PlainType, int, Avl.Image) |
Changes the type of pixel components.
|
| ConvertRectificationMap(Avl.RectificationMap, Optional<Avl.PlainType>, Optional<int>, int, Avl.RectificationMap) |
Converts a rectification map to a different format.
|
| ConvertSpatialMapToMatrixMaps(Avl.SpatialMap, bool, Avl.Matrix, Avl.Matrix) |
Splits a spatial map into two matrices of source coordinates.
|
| ConvertSpatialMap_ToNearest(Avl.SpatialMap, Avl.SpatialMap) |
Converts any spatial map to NearestNeighbour interpolation.
|
| ConvertSpatialMap(Avl.SpatialMap, Optional<Avl.PlainType>, Optional<int>, int, Avl.SpatialMap) |
Converts a spatial map to a different format.
|
| ConvertSurfaceType(Avl.Surface, Avl.PlainType, Optional<double>, Optional<double>, Avl.Surface) |
Changes the point Z coordinate type.
|
| ConvertToCumulativeHistogram(Avl.Histogram, Avl.Histogram) |
Computes the cumulative histogram of input histogram.
|
| ConvertToEquidistantPath(Avl.Path, float, Avl.EquidistanceType, Avl.Path) |
Creates a new path whose characteristic points lie on the input path, but are
equally spaced.
|
| ConvertToMultichannel(Avl.Image, Optional<Avl.Region>, int, Avl.Image) |
Creates a multichannel image from a monochromatic one by replicating its channel.
|
| ConvertToPlainType(Avl.TensorDataType) | |
| ConvertToTensorDataType(Avl.PlainType) | |
| ConvolveImage(Avl.Image, Optional<Avl.Region>, Avl.Matrix, bool, Optional<Avl.Location>, Avl.Image) |
Computes a convolution of the input image with a user-specified mask.
|
| ConvolveProfile(Avl.Profile, Optional<Avl.Range>, List<float>, bool, Optional<int>, Avl.Profile) |
Applies a user-defined convolution to a profile.
|
| CopyImageData(Avl.Image, Optional<Avl.Region>, Avl.Image) |
Creates an image copy with the same size and pixel format.
|
| CopyPixels(Avl.Image, Avl.Region, Avl.Image) |
Copies pixels from one image to another.
|
| CorrectGamma(Avl.Image, Optional<Avl.Region>, float, Avl.Image) |
Performs gamma correction.
|
| CreateAffineTransformMatrix(float, float, Avl.Vector2D, float, float, float, Avl.Matrix) |
Creates affine transform matrix matrix. Return product of matrices: Translation
* Rotation * Scale * Shearing.
|
| CreateArcFittingMap(Avl.ImageFormat, Avl.ArcFittingField, Optional<Avl.CoordinateSystem2D>, int, int, Avl.SamplingParams, Avl.ArcFittingMap, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Precomputes a data object that is required for fast arc fitting on images.
|
| CreateArcPath(Avl.Arc2D, int, Avl.Path) |
Creates an open path containing cocircular, equidistant points.
|
| CreateArc(Avl.Point2D, Avl.Anchor2D, float, float, float, Avl.Arc2D) |
Creates an arc from an aligned point, radius, and angle range.
|
| CreateBicircularCurve(Avl.Path, int, Avl.Path) |
Creates a bicircular curve passing through the points of the leading path.
|
| CreateBox3D(Avl.Point3D, Avl.Anchor3D, float, float, float, Avl.Box3D) |
Creates a box in 3D.
|
| CreateBoxBorderRegion(Avl.Box, int, Avl.BorderPosition, int, int, Avl.Region) |
Creates a frame-shaped region with given parameters.
|
| CreateBoxRegion(Avl.Box, int, int, Avl.Region) |
Creates a rectangular region corresponding to a given box.
|
| CreateBox(Avl.Location, Avl.Anchor2D, int, int, Avl.Box) |
Creates a box.
|
| CreateCircleFittingMap3D(Avl.SurfaceFormat, Avl.CircleFittingField, Optional<Avl.CoordinateSystem2D>, int, Optional<float>, int, Avl.InterpolationMethod, Avl.CircleFittingMap, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Precomputes a data object that is required for fast circle fitting on surfaces.
|
| CreateCircleFittingMap(Avl.ImageFormat, Avl.CircleFittingField, Optional<Avl.CoordinateSystem2D>, int, int, Avl.SamplingParams, Avl.CircleFittingMap, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Precomputes a data object that is required for fast circle fitting on images.
|
| CreateCirclePath(Avl.Circle2D, int, Avl.Path) |
Creates a closed path containing cocircular, equidistant points.
|
| CreateCircleRegion(Avl.Circle2D, Optional<Avl.CoordinateSystem2D>, int, int, Avl.Region, Optional<Avl.Circle2D>) |
Creates a circular region corresponding to a given circle.
|
| CreateCircle(Avl.Point2D, Avl.Anchor2D, float, Avl.Circle2D) |
Creates a circle from an aligned point and radius.
|
| CreateCoordinateSystemFromPoint(Avl.Point2D, float, float, float, Avl.CoordinateSystem2D) |
Creates a coordinate system with the specified origin.
|
| CreateCoordinateSystemFromRectangle(Avl.Rectangle2D, Avl.Anchor2D, float, float, float, Avl.CoordinateSystem2D) |
Creates a coordinate system from a rectangle.
|
| CreateCoordinateSystemFromSegment(Avl.Segment2D, float, float, float, float, Avl.CoordinateSystem2D) |
Creates a coordinate system with the origin on a given segment.
|
| CreateCoordinateSystemFromTwoPoints(Avl.Point2D, Avl.Point2D, float, float, float, Avl.CoordinateSystem2D) |
Creates a coordinate system with two points on its axes.
|
| CreateCoordinateSystemFromVector(Avl.Vector2D, float, float, float, Avl.CoordinateSystem2D) |
Creates a coordinate system from a vector.
|
| CreateCrossRegion(Avl.Box, int, int, Avl.Region) |
Creates a cross-shaped region with given parameters.
|
| CreateCylinderMap(Avl.ImageFormat, Avl.Rectangle2D, float, Optional<Avl.Point2D>, Optional<int>, Optional<int>, int, Avl.InterpolationMethod, Avl.CylinderMappingMode, Avl.SpatialMap, Optional<Avl.Region>) |
Creates a spatial map for transformations from a cylinder surface to a flat
rectangle.
|
| CreateDataPartition(List<List<float>>, List<int>, float, int, List<List<float>>, List<List<float>>, List<List<float>>, List<List<float>>) |
Divides the input set to test and train subsets, trying to maintain balance
in class distribution.
|
| CreateEdgeModel1(Avl.Image, Optional<Avl.Region>, Optional<Avl.Rectangle2D>, int, Optional<int>, float, float, float, float, float, float, float, float, float, float, Conditional<Avl.EdgeModel>, Optional<Conditional<Avl.Point2D>>, Optional<Conditional<List<Avl.Path>>>, Diagnostic<Conditional<List<Avl.Image>>>) |
Creates a model for edge-based template matching.
|
| CreateEdgeModel2(Avl.Image, Optional<Avl.Region>, Optional<Avl.Rectangle2D>, int, Optional<int>, float, float, float, float, float, float, float, float, float, float, Conditional<Avl.EdgeModel2>, Optional<Conditional<Avl.Point2D>>, Optional<Conditional<List<Avl.Path>>>, Diagnostic<Conditional<List<Avl.Image>>>) |
Creates a model for edge-based template matching.
|
| CreateEdgeModel_Elastic(Avl.Image, Optional<Avl.Region>, Optional<Avl.Rectangle2D>, Avl.AngleDifferenceTolerance, float, float, float, float, float, float, float, Conditional<Avl.EdgeModel_Elastic>, Optional<Conditional<Avl.Point2D>>, Optional<Conditional<List<Avl.Path>>>) |
Creates a model for edge-based template matching.
|
| CreateEllipsePath(Avl.Point2D, float, float, int, Avl.Path) |
Creates a closed path containing elliptical, equidistant points.
|
| CreateEllipseRegion(Avl.Rectangle2D, Optional<Avl.CoordinateSystem2D>, int, int, Avl.Region, Optional<Avl.Rectangle2D>) |
Creates an elliptic region of given bounding rectangle.
|
| CreateFlatSurface(int, int, Avl.PlainType, double, double, double, double, double, double, Optional<double>, Avl.Surface) |
Creates a uniform surface.
|
| CreateGammaCorrectionLut(float, Avl.PlainType, Avl.PixelLut) |
Creates Look Up Table for gamma correction operation on image pixels.
|
| CreateGoldenTemplate2(List<Avl.Image>, Optional<Avl.Region>, int, int, int, int, int, float, Avl.GoldenTemplate2Model) |
Create a model to be used with CompareGoldenTemplate2 filter.
|
| CreateGoldenTemplate_Edges(Avl.Image, Optional<Avl.Rectangle2D>, Optional<Avl.Region>, Optional<Avl.CoordinateSystem2D>, float, Optional<float>, float, float, Avl.EdgeGoldenTemplate, Diagnostic<Avl.Image>, Diagnostic<Avl.Region>, Diagnostic<Avl.Region>) |
Creates golden template for application in CompareGoldenTemplate_Edges filter.
|
| CreateGoldenTemplate_Intensity(Avl.Image, Optional<Avl.Rectangle2D>, Optional<Avl.Region>, Optional<Avl.CoordinateSystem2D>, float, int, Avl.GrayGoldenTemplate, Diagnostic<Avl.Image>, Diagnostic<Avl.Region>, Diagnostic<Avl.Region>) |
Creates golden template for application in CompareGoldenTemplate_Intensity filter.
|
| CreateGrayModel2(Avl.Image, Optional<Avl.Region>, Optional<Avl.Rectangle2D>, int, Optional<int>, float, float, float, float, float, float, Avl.GrayModel2, Optional<Avl.Point2D>, Diagnostic<List<Avl.Image>>) |
Creates a model for NCC or SAD template matching.
|
| CreateGrayModel(Avl.Image, Optional<Avl.Region>, Optional<Avl.Rectangle2D>, int, Optional<int>, float, float, float, float, float, float, Avl.GrayModel, Optional<Avl.Point2D>, Diagnostic<List<Avl.Image>>) |
Creates a model for NCC or SAD template matching.
|
| CreateGridRegion(Avl.Box, int, int, int, int, Avl.Region) |
Creates a grid-shaped region with given parameters.
|
| CreateHistogram(List<float>, Optional<List<double>>, Optional<float>, float, Optional<int>, bool, Avl.Histogram) |
Creates the histogram of the array of real numbers.
|
| CreateImageFromPoint3DGrid(Avl.Point3DGrid, float, float, float, Avl.Image) |
Creates a depth image from the Z-values of the input point grid.
|
| CreateImageFromSurface_AnyScales(Avl.Surface, Avl.PlainType, Optional<double>, Optional<double>, Optional<double>, Optional<double>, Optional<double>, Optional<double>, Optional<float>, Avl.Image, Optional<Avl.SurfaceFormat>) |
Creates a depth image from the Z-values of the input surface.
|
| CreateImageFromSurface(Avl.Surface, Avl.PlainType, Avl.ResampleSurfaceMode, Optional<double>, Optional<double>, Optional<double>, Optional<double>, Optional<float>, Avl.Image, Optional<Avl.SurfaceFormat>) |
Creates a depth image from the Z-values of the input surface.
|
| CreateImageInversePolarTransformMap(Avl.ImageFormat, Avl.Point2D, Avl.PolarSpaceType, Avl.InterpolationMethod, Avl.SpatialMap, Optional<Avl.Region>) |
Creates a spatial map representing an image inverse polar transform.
|
| CreateImagePolarTransformMap(Avl.ImageFormat, Avl.Point2D, Avl.PolarSpaceType, Avl.InterpolationMethod, Avl.SpatialMap, Optional<Avl.Region>) |
Creates a spatial map representing an image polar transform.
|
| CreateImagePyramid_Gauss(Avl.Image, Avl.GaussKernel, int, int, Avl.DownsampleFunction, List<Avl.Image>) |
Creates an array of images, each downsampled from the previous, gauss-smoothed
one.
|
| CreateImagePyramid(Avl.Image, int, int, Avl.DownsampleFunction, List<Avl.Image>) |
Creates an array of images, each downsampled from the previous one.
|
| CreateImageResizeMap(Avl.ImageFormat, int, int, Avl.InterpolationMethod, Avl.SpatialMap, Optional<Avl.Region>) |
Creates a spatial map representing an image resizing.
|
| CreateImageRotationMap(Avl.ImageFormat, float, Avl.RotationSizeMode, Avl.InterpolationMethod, Avl.SpatialMap, Optional<Avl.Region>) |
Creates a spatial map representing an image rotation.
|
| CreateImageTiles_AsBoxes(Avl.Size, int, Optional<int>, Optional<int>, Optional<int>, Avl.OverflowControl, List<Avl.Box>, int, int) |
Generates an array of boxes covering the area of an image.
|
| CreateImageTiles(Avl.Size, int, Optional<int>, Optional<int>, Optional<int>, Avl.OverflowControl, List<Avl.Region>, List<Avl.Box>, int, int) |
Generates an array of regions and an array of boxes covering the area of an
image.
|
| CreateLineRegion(Avl.Line2D, Optional<Avl.CoordinateSystem2D>, float, int, int, Avl.Region, Optional<Avl.Line2D>) |
Creates a line region.
|
| createLine(Avl.Point2D, float) | |
| CreateLogarithmLut(Optional<float>, float, bool, Avl.PlainType, Avl.PixelLut) |
Creates Look Up Table for logarithm operation on image pixels.
|
| CreateMatrixTransformMap(Avl.ImageFormat, Optional<Avl.Region>, Avl.Matrix, Optional<Avl.Size>, Avl.InterpolationMethod, Avl.SpatialMap) |
Creates a spatial map which performs transform defined as a 3x3 homography matrix.
|
| CreateMeasurementMap(Avl.ImageFormat, Avl.SegmentScanField, Optional<Avl.CoordinateSystem2D>, int, int, Avl.InterpolationMethod, List<Avl.ScanMap>, Optional<Avl.SegmentScanField>, Diagnostic<List<Avl.Segment2D>>) |
(Pre)computes image sampling locations used by MeasureObjectWidth function.
|
| CreatePathBorderRegion(Avl.Path, Optional<Avl.CoordinateSystem2D>, float, Avl.BorderPosition, int, int, Avl.Region, Optional<Avl.Path>) |
Creates a region along a given path. The region may be internal or external
to the path.
|
| CreatePathFittingMap3D(Avl.SurfaceFormat, Avl.PathFittingField, Optional<Avl.CoordinateSystem2D>, Optional<float>, Optional<float>, int, Avl.InterpolationMethod, Avl.PathFittingMap, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Precomputes a data object that is required for fast path fitting on surfaces.
|
| CreatePathFittingMap(Avl.ImageFormat, Avl.PathFittingField, Optional<Avl.CoordinateSystem2D>, Optional<float>, int, Avl.SamplingParams, Avl.PathFittingMap, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Precomputes a data object that is required for fast path fitting on images.
|
| CreatePathRegion(Avl.Path, Optional<Avl.CoordinateSystem2D>, float, int, int, Avl.Region, Optional<Avl.Path>) |
Creates a region along the given path.
|
| CreatePCATransform(Avl.Matrix, int, Optional<float>, Avl.PCAModel, Avl.Matrix, Diagnostic<Avl.Matrix>, Diagnostic<Avl.Matrix>, Diagnostic<List<int>>) |
Performs the Principal Component Analysis (PCA) on provided data, creates the
feature vector and normalization coefficients (mean and standard deviation of
variables).
|
| CreatePerspectiveMap_Path(Avl.ImageFormat, Optional<Avl.Region>, Avl.Path, Optional<Avl.Path>, Optional<Avl.Size>, Avl.InterpolationMethod, Avl.SpatialMap, Avl.Matrix) |
Creates a perspective transform map from planes defined by paths.
|
| CreatePerspectiveMap_Points(Avl.ImageFormat, Optional<Avl.Region>, List<Avl.Point2D>, Optional<List<Avl.Point2D>>, Optional<Avl.Size>, Avl.InterpolationMethod, Avl.SpatialMap, Avl.Matrix) |
Creates a perspective transform map from four points denoting a rectangle in
the world coordinates.
|
| CreatePincushionMap(Avl.ImageFormat, float, Optional<Avl.Point2D>, Avl.InterpolationMethod, Avl.SpatialMap) |
Creates a spatial map for removing/adding pincushion distortion, using divisional
lens distortion model.
|
| CreatePoint3DGridFromImage(Avl.Image, Optional<Avl.Region>, Avl.PointCloudCoordinateTransform, Avl.PointCloudCoordinateTransform, Avl.PointCloudCoordinateTransform, Avl.Point3DGrid) |
Creates a Point3DGrid structure from coordinates encoded in pixels of image.
|
| CreatePointGraph(List<Avl.Point2D>, int, float, Optional<float>, Optional<float>, List<List<int>>, List<List<float>>, Diagnostic<List<Avl.Segment2D>>) |
Creates a graph of points that lie close to each other.
|
| CreatePointGrid(Avl.Point2D, Avl.Anchor2D, int, int, float, float, List<Avl.Point2D>) |
Creates a grid of points.
|
| CreatePolygonRegion(Avl.Path, Optional<Avl.CoordinateSystem2D>, int, int, Avl.Region, Optional<Avl.Path>) |
Creates a polygonal region corresponding to a given closed path.
|
| CreatePowerLut(float, Avl.PlainType, Avl.PixelLut) |
Creates Look Up Table for power operation on image pixels.
|
| CreateRandomPointArray(int, Avl.Box, float, Optional<int>, List<Avl.Point2D>) |
Creates array of random points inside given box.
|
| CreateRectangleBorderRegion(Avl.Rectangle2D, Optional<Avl.CoordinateSystem2D>, float, Avl.BorderPosition, int, int, Avl.Region, Optional<Avl.Rectangle2D>) |
Creates a frame-shaped region with given parameters.
|
| CreateRectanglePath(Avl.Rectangle2D, Avl.Path) |
Creates a closed path containing four vertices of rectangle.
|
| CreateRectangleRegion(Avl.Rectangle2D, Optional<Avl.CoordinateSystem2D>, int, int, Avl.Region, Optional<Avl.Rectangle2D>) |
Creates a region corresponding to a given rectangle.
|
| CreateRectangle(Avl.Point2D, Avl.Anchor2D, float, float, float, Avl.Rectangle2D) |
Creates a rectangle from an aligned point.
|
| CreateRectificationMap_Advanced(Avl.ImageFormat, Avl.CreateSpatialMapUnit, Optional<Avl.Point2D>, Avl.CreateSpatialMapUnit, Optional<float>, Optional<float>, Optional<float>, bool, Avl.InterpolationMethod, Avl.RectificationTransform, Avl.RectificationMap) |
Computes a spatial map for transforming distorted images to rectified images
defined in world coordinate plane. Allows for flexible definition of output
geometry.
|
| CreateRectificationMap_Basic(Avl.Image, float, float, List<Avl.AnnotatedPoint2D>, Avl.RectificationMap) |
Computes a spatial map for removing lens and perspective distortion directly
from an image containing circles calibration pattern. Internally uses a pinhole
camera model with polynomial lens distortion.
|
| CreateRectificationMap_PixelUnits(Avl.ImageFormat, Optional<Avl.Point2D>, Optional<int>, Optional<int>, Optional<float>, bool, Avl.InterpolationMethod, Avl.RectificationTransform, Avl.RectificationMap) |
Computes a spatial map for transforming distorted images to rectified images
defined in world coordinate plane. Defines the output geometry in pixels.
|
| CreateRectificationMap_WorldUnits(Avl.ImageFormat, float, float, float, float, Optional<float>, bool, Avl.InterpolationMethod, Avl.RectificationTransform, Avl.RectificationMap) |
Computes a spatial map for transforming distorted images to rectified images
defined in world coordinate plane. Defines the output geometry in world units.
|
| CreateRingRegion(Avl.Circle2D, Optional<Avl.CoordinateSystem2D>, float, Avl.BorderPosition, int, int, Avl.Region, Optional<Avl.Circle2D>) |
Creates a ring-shaped region with given parameters.
|
| CreateRing(Avl.Point2D, Avl.Anchor2D, float, float, Avl.Ring2D) |
Creates a ring from an aligned point, inner and outer radius, and angle range.
|
| CreateScanMap(Avl.ImageFormat, Avl.Path, Optional<Avl.CoordinateSystem2D>, int, Avl.SamplingParams, Avl.ScanMap, Optional<Avl.Path>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Precomputes a data object that is required for fast 1D edge detection.
|
| CreateSegment3D(Avl.Point3D, float, Avl.Vector3D, float, Avl.Segment3D) |
Produces a segment in 3D of given parameters.
|
| CreateSegmentFittingMap3D(Avl.SurfaceFormat, Avl.SegmentFittingField, Optional<Avl.CoordinateSystem2D>, int, Optional<float>, int, Avl.InterpolationMethod, Avl.SegmentFittingMap, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Precomputes a data object that is required for fast segment fitting on surfaces.
|
| CreateSegmentFittingMap(Avl.ImageFormat, Avl.SegmentFittingField, Optional<Avl.CoordinateSystem2D>, int, int, Avl.SamplingParams, Avl.SegmentFittingMap, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Precomputes a data object that is required for fast segment fitting on images.
|
| CreateSegmentPath(Avl.Point2D, Avl.Point2D, int, Avl.Path) |
Creates an open path containing collinear, equidistant points.
|
| CreateSegmentRegion(Avl.Segment2D, Optional<Avl.CoordinateSystem2D>, float, int, int, bool, Avl.Region, Optional<Avl.Segment2D>) |
Creates a segment region.
|
| createSegment(Avl.Point2D, float, float) | |
| CreateSegment(Avl.Point2D, float, float, float, Avl.Segment2D) |
Produces a segment of given parameters.
|
| CreateShapeRegionRegion(Avl.ShapeRegion, Optional<Avl.CoordinateSystem2D>, int, int, Avl.Region, Optional<Avl.ShapeRegion>) |
Creates a region corresponding to the given shape region.
|
| CreateSphereMap(Avl.ImageFormat, Avl.Rectangle2D, float, Optional<int>, int, Avl.InterpolationMethod, Avl.SpatialMap, Optional<Avl.Region>) |
Creates a spatial map for transformations from a sphere surface to a flat rectangle.
|
| CreateSurfaceFromImage(Avl.Image, Optional<Avl.Region>, Avl.PointCloudCoordinateTransform, Avl.PointCloudCoordinateTransform, Avl.PointCloudCoordinateTransform, Avl.OutputSurfaceFormat, Avl.Surface, Diagnostic<Avl.Region>, Diagnostic<Avl.Point3DGrid>) |
Creates a Surface structure from coordinates encoded in pixels of an image.
|
| CreateSurfaceMeasurementMap(Avl.SurfaceFormat, Avl.SegmentScanField, Optional<Avl.CoordinateSystem2D>, int, Optional<float>, int, Avl.InterpolationMethod, List<Avl.ScanMap>, Optional<Avl.SegmentScanField>, Diagnostic<List<Avl.Segment2D>>) |
(Pre)computes surface sampling locations used by MeasureObjectWidth3D function.
|
| CreateSurfaceScanMap(Avl.SurfaceFormat, Avl.Path, Optional<Avl.CoordinateSystem2D>, Optional<float>, int, Avl.InterpolationMethod, Avl.ScanMap, Optional<Avl.Path>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Precomputes a data object that is required for fast 1D edge detection in 3D.
|
| CreateUniformHistogram(double, float, float, int, Avl.Histogram) |
Creates a uniform histogram of desired parameters with common value of all bins.
|
| CreateUniformProfile(float, int, float, float, Avl.Profile) |
Creates a profile with all its elements set to the same value.
|
| createVector(Avl.Point2D, Avl.Point2D) | |
| createVector(float, float) | |
| CreateVector(float, float, Avl.Vector2D) |
Produces a vector of given length and direction.
|
| CropHistogram(Avl.Histogram, int, int, Avl.Histogram) |
Confines a histogram to its continuous segment.
|
| CropImageToQuadrangle(Avl.Image, Avl.Path, Optional<Avl.CoordinateSystem2D>, Optional<Avl.Size>, Avl.InterpolationMethod, int, Avl.Pixel, Avl.Image, Optional<Avl.Path>) |
Creates an image from a quadrangle on another image.
|
| CropImageToRectangle(Avl.Image, Avl.Rectangle2D, Optional<Avl.CoordinateSystem2D>, Avl.CropScaleMode, Avl.InterpolationMethod, float, Avl.Pixel, Avl.Image, Optional<Avl.Rectangle2D>, Optional<Avl.CoordinateSystem2D>) |
Creates an image from a rectangular fragment of another image (with black margins
if requested).
|
| CropImage(Avl.Image, Avl.Box, Avl.Pixel, Avl.Image) |
Creates an image from a box-shaped fragment of the input image (with margins
if requested).
|
| CropPoint3DGridByNeighborsProximity(Avl.Point3DGrid, int, float, Avl.Metric3D, float, Avl.Point3DGrid) |
Removes from the grid points that are too distant from their neighbor points.
|
| CropPoint3DGridByPlaneProximity(Avl.Point3DGrid, Avl.Plane3D, float, Avl.Point3DGrid) |
Removes from the grid points that are too distant from a given plane.
|
| CropPoint3DGridToRegion(Avl.Point3DGrid, Avl.Region, Avl.Point3DGrid) |
Removes points that are not represented in a given region of the input grid.
|
| CropPoint3DGrid(Avl.Point3DGrid, Avl.ValueLimits, Avl.ValueLimits, Avl.ValueLimits, Avl.Point3DGrid) |
Removes from the grid points that are not contained in a given rectangular box.
|
| CropProfile(Avl.Profile, int, Optional<int>, Avl.Profile) |
Confines a profile to its continuous subsequence.
|
| CropRegionToQuadrangle(Avl.Region, Avl.Path, Optional<Avl.Size>, Optional<Avl.CoordinateSystem2D>, Avl.Region, Optional<Avl.Path>) |
Creates a region from a quadrangular fragment of another one. The quadrangle
must be convex.
|
| CropRegionToRectangle(Avl.Region, Avl.Rectangle2D, Optional<Avl.CoordinateSystem2D>, Avl.Region, Optional<Avl.Rectangle2D>, Optional<Avl.CoordinateSystem2D>) |
Creates a region from a rectangular fragment of another one.
|
| CropRegion(Avl.Region, Avl.Box, Avl.Region) |
Creates a region from a rectangular fragment of another one.
|
| CropSpatialMap(Avl.SpatialMap, Avl.Box, Avl.Box, Avl.SpatialMap) |
Crops a spatial map to the specified input and output boxes.
|
| CropSurfaceByNeighborsProximity(Avl.Surface, Optional<Avl.Region>, int, float, Avl.Metric3D, float, bool, Avl.Surface, Optional<Avl.Region>) |
Removes from the surface points that are too distant from their neighbor points.
|
| CropSurfaceByPlaneProximity(Avl.Surface, Optional<Avl.Region>, Avl.Plane3D, Optional<float>, Optional<float>, bool, Avl.Surface, Optional<Avl.Region>) |
Removes from the surface points that are too distant from a given plane.
|
| CropSurfaceToBox3D(Avl.Surface, Optional<Avl.Region>, Avl.Box3D, bool, Avl.Surface, Optional<Avl.Region>) |
Removes from the surface points that are not contained in a given box in 3D.
|
| CropSurfaceToRegion(Avl.Surface, Avl.Region, bool, Avl.Surface) |
Removes points that are not present in a given region.
|
| CropSurface_Dynamic(Avl.Surface, Optional<Avl.Region>, int, Optional<int>, Optional<float>, Optional<float>, float, bool, Avl.Surface, Optional<Avl.Region>, Diagnostic<Avl.Surface>) |
Removes from the surface points that are relatively too distant from their average
neighbor points in a local rectangular neighborhood.
|
| CropSurface_Relative(Avl.Surface, Optional<Avl.Region>, Avl.Surface, Optional<float>, Optional<float>, float, bool, Avl.Surface, Optional<Avl.Region>) |
Removes from the surface points that are relatively too distant from their average
neighbor points in a local rectangular neighborhood.
|
| CropSurface(Avl.Surface, Optional<Avl.Region>, Avl.ValueLimits_f64, Avl.ValueLimits_f64, Avl.ValueLimits_f64, bool, Avl.Surface, Optional<Avl.Region>) |
Removes from the surface points that are not contained in a given rectangular
box.
|
| crossProductMatrix(Avl.Vector3D) | |
| crossProduct(Avl.Vector2D, Avl.Vector2D) | |
| crossProduct(Avl.Vector3D, Avl.Vector3D) | |
| CutImageIntoTiles(Avl.Image, int, Optional<int>, Optional<int>, Optional<int>, Avl.OverflowControl, List<Avl.Image>) |
Generates an array of small images by cutting the input image.
|
| DaPImageMedian(Avl.Image, Optional<Avl.Region>, Avl.AngleRange, float) |
Computes the average direction within the region of interest.
|
| DebugPreviewCloseAllWindows() |
Closes all active debug preview windows and terminates preview window subsystem.
|
| DebugPreviewCloseWindow(Avl.DebugPreviewWindowState) |
Closes debug preview window.
|
| DebugPreviewShowImage(Avl.DebugPreviewWindowState, Avl.Image, string, int, int) |
Shows image in separated window. When called first time creates new window with
size fit to image.
|
| DebugPreviewShowNewImage(Avl.Image, string, int, int) |
Creates new separated window and shows image in it. DebugPreviewCloseAllWindows
need to be called to free resources reserved by this function.
|
| DebugPreviewShowNewRegion(Avl.Region, string, int, int) |
Creates new separated window and shows region in it. DebugPreviewCloseAllWindows
need to be called to free resources reserved by this function.
|
| DebugPreviewShowRegion(Avl.DebugPreviewWindowState, Avl.Region, string, int, int) |
Shows region in separated window. When called first time creates new window
with size fit to region.
|
| DebugPreviewWaitForAnyWindowClose() |
Waits until user closes any of active debug windows.
|
| DebugPreviewWaitForWindowsClose() |
Waits until user closes all active debug windows.
|
| DecodeBarcode(List<float>, Optional<Avl.BarcodeFormat>, Conditional<string>, Conditional<Avl.BarcodeFormat>, Conditional<float>, Conditional<int>, Conditional<int>) |
Translates an array of bar widths to sequence of digits or text in accordance
to the selected barcode standard.
|
| DecodeDataMatrix(Avl.Image, bool, Conditional<string>, Conditional<Avl.DataMatrixType>) |
Translates an image of 0 or 255 values to a text in accordance to how DataMatrix
codes are encoded.
|
| DecodeQRCode(Avl.Image, bool, Conditional<string>) |
Translates a matrix of 0 or 1 values to a text in accordance to how QR codes
are encoded.
|
| DeepModelToClassifyObjectModelDirectory(string, string) |
Conversion between DeepModel and ClassifyObjectModelDirectory
|
| DeepModelToDetectAnomalies1ModelDirectory(string, string) |
Conversion between DeepModel and DetectAnomalies1ModelDirectory
|
| DeepModelToDetectAnomalies2ModelDirectory(string, string) |
Conversion between DeepModel and DetectAnomalies2ModelDirectory
|
| DeepModelToDetectFeaturesModelDirectory(string, string) |
Conversion between DeepModel and DetectFeaturesModelDirectory
|
| DeepModelToLocatePointsModelDirectory(string, string) |
Conversion between DeepModel and LocatePointsModelDirectory
|
| DeepModelToSegmentInstancesModelDirectory(string, string) |
Conversion between DeepModel and SegmentInstancesModelDirectory
|
| DemarcateRegions(List<Avl.Region>, Optional<Avl.Metric>, List<Avl.Region>) |
Splits common pixels of the input regions among these regions.
|
| DetectArc_LSD(Avl.Image, Optional<Avl.Region>, Avl.GaussKernel, float, int, List<Avl.Arc2D>) |
Finds arcs in an image using Line Segment Detection method.
|
| DetectCalibrationGrid_Chessboard(Avl.Image, Optional<Avl.Region>, Avl.Size, bool, List<Avl.AnnotatedPoint2D>) |
Detects a chessboard calibration grid on the image, and returns calibration
points where 4 chessboard squares meet.
|
| DetectCalibrationGrid_Circles(Avl.Image, Optional<Avl.Region>, float, float, Avl.Polarity, List<Avl.AnnotatedPoint2D>, Diagnostic<Avl.Region>, Diagnostic<List<Avl.Point2D>>) |
Detects an arbitrary size symmetric circle pattern on the image.
|
| DetectCircle_LSD(Avl.Image, Optional<Avl.Region>, Avl.GaussKernel, float, float, int, List<Avl.Circle2D>) |
Finds circles in the input image using Line Segment Detection method.
|
| DetectCorners_CornerResponse(Avl.Image, Optional<Avl.Region>, Avl.CornerResponseMethod, int, Optional<float>, Optional<List<Avl.Point2D>>, Optional<Avl.Image>) |
Detects corners using corner response method.
|
| DetectCorners_Foerstner(Avl.Image, Optional<Avl.Region>, float, float, int, List<Avl.Point2D>, Diagnostic<Avl.Image>, Diagnostic<Avl.Image>) |
Detects corners using the Foerstner algorithm.
|
| DetectEdges_AsPaths_Mask(Avl.Image, Optional<Avl.Region>, Avl.EdgeMaskFilter, float, float, Optional<float>, float, float, Optional<float>, float, List<Avl.Path>, Diagnostic<Avl.Image>, Diagnostic<Avl.Region>) |
Extracts subpixel-precise paths that represent continuous edges. Faster, yet
less accurate version.
|
| DetectEdges_AsPaths(Avl.Image, Optional<Avl.Region>, Avl.EdgeFilter, float, Optional<float>, float, float, Optional<float>, float, float, Optional<float>, float, List<Avl.Path>, Diagnostic<Avl.Image>, Diagnostic<Avl.Region>) |
Extracts subpixel-precise paths that represent continuous edges.
|
| DetectEdges_AsRegion_Mask(Avl.Image, Optional<Avl.Region>, Avl.EdgeMaskFilter, float, float, float, int, Avl.Region, Diagnostic<Avl.Image>) |
Extracts a pixel-precise region of continuous edges. Faster, yet less accurate
version.
|
| DetectEdges_AsRegion(Avl.Image, Optional<Avl.Region>, Avl.EdgeFilter, float, Optional<float>, float, float, float, int, Avl.Region, Diagnostic<Avl.Image>) |
Extracts a pixel-precise region of continuous edges.
|
| DetectEdges(Avl.Image, Optional<Avl.Region>, Avl.EdgeFilter, float, Optional<float>, float, float, float, int, Avl.Image, Diagnostic<Avl.Image>) |
Extracts a binary image of pixel-precise continuous edges.
|
| DetectLinePeak_Gauss(Avl.Image, float, float, float, List<Conditional<Avl.Point2D>>, Diagnostic<Avl.Profile>) |
Finds line peaks on an image.
|
| DetectLinePeak(Avl.Image, Avl.LinePeakDetectionMethod, float, List<Conditional<Avl.Point2D>>, Diagnostic<Avl.Profile>) |
Finds line peaks on an image.
|
| DetectLines(Avl.Image, Optional<Avl.Region>, float, float, float, float, float, List<Avl.Line2D>, List<float>, Diagnostic<Avl.Image>, Diagnostic<Avl.Image>) |
Finds lines in an image using Hough Transform.
|
| DetectMultipleCircles(Avl.Image, Optional<Avl.Region>, float, float, float, float, List<Avl.HoughCircle>, Diagnostic<Avl.Image>, Diagnostic<Avl.Image>) |
Finds circles of a given radius in the input image using Hough Transform.
|
| DetectPaths(Avl.Image, Optional<Avl.Region>, Avl.Path, float, float, List<Avl.Path>, List<float>, Diagnostic<Avl.Image>, Diagnostic<Avl.Image>) |
Finds a specified shape in an image using Hough Transform.
|
| DetectPointSegments(List<Avl.Point2D>, float, int, Optional<float>, float, int, List<Avl.Segment2D>, List<Avl.Path>) |
Detect points that lie along multiple segments.
|
| DetectPolygons_LSD(Avl.Image, Optional<Avl.Region>, Avl.Path, Avl.GaussKernel, float, float, List<Avl.Path>) |
Finds a specified polygons in an image using Line Segment Detection method.
|
| DetectRidges_AsPaths(Avl.Image, Optional<Avl.Region>, float, Optional<float>, float, float, Avl.Polarity, List<Avl.Path>) |
Extracts subpixel-precise paths that represent bright or dark thin lines.
|
| DetectRidges_AsRegion(Avl.Image, Optional<Avl.Region>, float, Optional<float>, float, float, Avl.Polarity, int, Avl.Region) |
Extracts a pixel-precise region of bright or dark thin lines.
|
| DetectSegments_LSD(Avl.Image, Optional<Avl.Region>, Avl.GaussKernel, float, int, List<Avl.Segment2D>) |
Finds segments in an image using Line Segment Detection method.
|
| DetectSegments(Avl.Image, Optional<Avl.Region>, float, float, float, float, float, float, List<Avl.Segment2D>, Diagnostic<Avl.Image>, Diagnostic<Avl.Image>) |
Finds segments in an image using Hough Transform.
|
| DetectSingleCircle(Avl.Image, Optional<Avl.Region>, float, float, float, Conditional<Avl.HoughCircle>, Diagnostic<Avl.Image>, Diagnostic<Avl.Image>) |
Finds the strongest circle of a given radius in the input image.
|
| DifferenceHistogram(Avl.Histogram, Avl.Histogram, Avl.Histogram) |
Computes histogram representing difference between corresponding bars of given
histograms.
|
| DifferenceImage_Flex(Avl.Image, Avl.Image, Optional<Avl.Box>, Optional<Avl.Box>, int, Optional<int>, Avl.TileTranslationMode, bool, Avl.Image) |
Computes the non-negative distances between corresponding pixel values using
tiles.
|
| DifferenceImage_Shifted(Avl.Image, Avl.Image, Avl.Box, Avl.Box, Avl.Image) |
Computes the non-negative distances between corresponding pixel values.
|
| DifferenceImage(Avl.Image, Avl.Image, Optional<Avl.Region>, Avl.Image) |
Computes the non-negative distances between corresponding pixel values.
|
| DifferenceOfGaussians(Avl.Image, Optional<Avl.Region>, float, float, float, float, Avl.Image, Diagnostic<Avl.Profile>) |
Applies difference of Gaussians on an image, i.e. computes difference of two
Gaussian smoothed images.
|
| DifferenceProfile(Avl.Profile, Avl.Profile, Avl.Profile) |
Computes profile representing difference between corresponding values of given
profiles.
|
| DifferentiateProfile_Step(Avl.Profile, bool, int, Avl.Profile) |
Computes the derivative of a profile with a given difference step.
|
| DifferentiateProfile(Avl.Profile, bool, Avl.DifferentiationMethod, Avl.Profile) |
Computes the derivative of a profile.
|
| DilateAndErodeImage(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, Optional<Avl.Pixel>, Avl.KernelShape, int, Optional<int>, Avl.Image, Avl.Image) |
Calculates dilation and erosion simultaneously for faster execution.
|
| DilateBox(Avl.Box, int, Optional<int>, Avl.Box) |
Performs a morphological dilation on a box using box kernel.
|
| DilateImage_AnyKernel(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, Optional<Avl.Pixel>, Avl.Region, Optional<Avl.Location>, Avl.Image) |
Replaces each pixel with the maximum of pixels within an arbitrary kernel.
|
| DilateImage_Mask(Avl.Image, Optional<Avl.Region>, Avl.MorphologyKernel, Avl.Image) |
Replaces each pixel with the maximum of pixels within a small rectangular kernel.
|
| DilateImage(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, Optional<Avl.Pixel>, Avl.KernelShape, int, Optional<int>, Avl.Image, Diagnostic<Avl.Region>) |
Replaces each pixel with the maximum of pixels within a kernel.
|
| DilatePolygon(Avl.Path, float, bool, Avl.Path) |
Enlarges a polygon by a given radius.
|
| DilateProfile(Avl.Profile, Optional<Avl.Range>, int, bool, Avl.Profile) |
Changes a profile by choosing maximum point within a kernel.
|
| DilateRegion_AnyKernel(Avl.Region, Avl.Region, Optional<Avl.Location>, Avl.Region) |
Performs a morphological dilation on a region using an arbitrary kernel.
|
| DilateRegion(Avl.Region, Avl.KernelShape, int, Optional<int>, Avl.Region) |
Performs a morphological dilation on a region using a predefined kernel.
|
| DilateShapeRegion(Avl.ShapeRegion, float, Avl.ShapeRegion) |
Performs a morphological dilation on a shape region.
|
| DilateSurfacePoints(Avl.Surface, Optional<Avl.Region>, Avl.KernelShape, int, Optional<int>, Avl.Surface) |
Reconstructs missing points of the input surface by interpolating neighboring
points.
|
| direction(Avl.Point2D, Avl.Point2D) | |
| direction(float, float, float, float) | |
| DirectoryToClassifyObjectModelDirectory(string, string) |
Conversion between Directory and ClassifyObjectModelDirectory
|
| DirectoryToDetectAnomalies1ModelDirectory(string, string) |
Conversion between Directory and DetectAnomalies1ModelDirectory
|
| DirectoryToDetectAnomalies2ModelDirectory(string, string) |
Conversion between Directory and DetectAnomalies2ModelDirectory
|
| DirectoryToDetectFeaturesModelDirectory(string, string) |
Conversion between Directory and DetectFeaturesModelDirectory
|
| DirectoryToLocatePointsModelDirectory(string, string) |
Conversion between Directory and LocatePointsModelDirectory
|
| DirectoryToSegmentInstancesModelDirectory(string, string) |
Conversion between Directory and SegmentInstancesModelDirectory
|
| DischargeAVLImageMemoryPools() | |
| DischargeImageMemoryPools() |
Releases preallocated image memory buffers.
|
| DistanceTransform(Avl.Image, int, float, float, float, Avl.Image) |
Computes an image in which the pixel values denote the estimated distances to
the nearest bright pixel in the input image.
|
| distance(Avl.Point2D, Avl.Line2D) | |
| distance(Avl.Point2D, Avl.Point2D) | |
| DivideHistograms(Avl.Histogram, Avl.Histogram, Avl.Histogram) |
Divides two histograms bar by bar.
|
| DivideHistogram(Avl.Histogram, double, Avl.Histogram) |
Divides each bin value by a number.
|
| DivideImages(Avl.Image, Avl.Image, Optional<Avl.Region>, float, Avl.Image) |
Divides two images pixel by pixel.
|
| DivideImage(Avl.Image, Optional<Avl.Region>, float, Avl.Image) |
Divides each pixel by a scalar value.
|
| DivideProfiles(Avl.Profile, Avl.Profile, Avl.Profile) |
Divides two profiles value by value.
|
| DivideProfile(Avl.Profile, Optional<Avl.Range>, float) |
Divides each element of a profile by a scalar value.
|
| dotProduct(Avl.Vector2D, Avl.Vector2D) | |
| dotProduct(Avl.Vector3D, Avl.Vector3D) | |
| DownsampleImage_Midlevels(Avl.Image, int, Avl.MidlevelScale, Avl.Image) |
Shrinks an image by the factor of 1.5 or SQRT(2) along each axis.
|
| DownsampleImage(Avl.Image, int, Avl.DownsampleFunction, Avl.Image) |
Shrinks an image by the factor of two along each axis.
|
| DownsampleRegion(Avl.Region, Avl.DownsampleRegionMode, int, Avl.Region) |
Shrinks a region by the factor of two along each axis.
|
| DrawArc(Avl.Image, Avl.Arc2D, Optional<Avl.CoordinateSystem2D>, Avl.Pixel, Avl.DrawingStyle) |
Draws an arc on an image.
|
| DrawBox(Avl.Image, Avl.Box, Avl.Pixel, float) |
Draws a box on an image.
|
| DrawCircle(Avl.Image, Avl.Circle2D, Optional<Avl.CoordinateSystem2D>, Avl.Pixel, Avl.DrawingStyle) |
Draws a circle on an image.
|
| DrawCoordinateSystem(Avl.Image, Avl.CoordinateSystem2D, Optional<Avl.CoordinateSystem2D>, Avl.Pixel, Avl.DrawingStyle, float, float) |
Draws a pair of arrows representing a coordinate system on an image.
|
| DrawCrosshair(Avl.Image, Avl.Location, Optional<Avl.CoordinateSystem2D>, Avl.Pixel, Avl.CrosshairShape, Avl.DrawingStyle) |
Draws a crosshair on an image.
|
| DrawDimensionLine(Avl.Image, Avl.Segment2D, Optional<Avl.CoordinateSystem2D>, Avl.Pixel, Avl.DrawingStyle, float, float, Avl.MetricUnit, int, float) |
Draws a dimension line on an image.
|
| DrawEllipse(Avl.Image, Avl.Rectangle2D, Optional<Avl.CoordinateSystem2D>, Avl.Pixel, Avl.DrawingStyle) |
Draws an ellipse on an image.
|
| DrawGridImage(Avl.Image, Avl.Image, int, int, Optional<int>, Optional<int>) |
Draws an image as a tile on an image considered to be a grid of tiles.
|
| DrawImagesGrid(List<Avl.Image>, int, int, Optional<Avl.Size>, Avl.Image) |
Draws a grid of images.
|
| DrawImage(Avl.Image, Avl.Image, Avl.Location) |
Draws an image on another one.
|
| DrawLine(Avl.Image, Avl.Line2D, Optional<Avl.CoordinateSystem2D>, Avl.Pixel, Avl.DrawingStyle) |
Draws a line on an image.
|
| DrawPath(Avl.Image, Avl.Path, Optional<Avl.CoordinateSystem2D>, Avl.Pixel, Avl.DrawingStyle) |
Draws a path on an image.
|
| DrawPoint(Avl.Image, Avl.Point2D, Optional<Avl.CoordinateSystem2D>, Avl.Pixel, Avl.DrawingStyle) |
Draws a point on an image.
|
| DrawRectangle(Avl.Image, Avl.Rectangle2D, Optional<Avl.CoordinateSystem2D>, Avl.Pixel, Avl.DrawingStyle) |
Draws a rectangle on an image.
|
| DrawRegion(Avl.Image, Avl.Region, Optional<Avl.CoordinateSystem2D>, Avl.Pixel, float) |
Draws a region on an image.
|
| DrawSegment(Avl.Image, Avl.Segment2D, Optional<Avl.CoordinateSystem2D>, Avl.Pixel, Avl.DrawingStyle, Avl.MarkerType, float) |
Draws a segment on an image.
|
| DrawShapeRegion(Avl.Image, Avl.ShapeRegion, Optional<Avl.CoordinateSystem2D>, Avl.Pixel, Avl.DrawingStyle, bool) |
Draws a shape region on an image.
|
| DrawString(Avl.Image, string, Avl.Location, Optional<Avl.CoordinateSystem2D>, Avl.Anchor2D, Avl.Pixel, Avl.DrawingStyle, float, float, Optional<Avl.Pixel>) |
Draws a string on an image.
|
| DrawVector(Avl.Image, Avl.Vector2D, Avl.Point2D, Optional<Avl.CoordinateSystem2D>, Avl.Pixel, Avl.DrawingStyle, float) |
Draws a vector at an associated initial point on an image.
|
| EdgeModel2ByteSize(Avl.EdgeModel2, long) |
Returns estimated size of the EdgeModel2 in bytes.
|
| EdgeModel_ElasticByteSize(Avl.EdgeModel_Elastic, long) |
Returns estimated size of the EdgeModel_Elastic in bytes.
|
| Ellipse2DToRectangle2D(Avl.Ellipse2D, Avl.Rectangle2D) |
Converts an ellipse to a rectangle.
|
| Ellipse2DToShapeRegion(Avl.Ellipse2D, Avl.ShapeRegion) |
Converts an ellipse to region of interest.
|
| EllipseArea(Avl.Ellipse2D, float) |
Computes the area of an ellipse.
|
| EllipseBoundingBox(Avl.Ellipse2D, Avl.Box) |
Computes the smallest box containing an ellipse.
|
| EllipseBoundingRectangle_FixedAngle(Avl.Ellipse2D, float, Avl.Rectangle2D, Optional<Avl.Point2D>, Optional<float>, Optional<float>) |
Computes the smallest rectangle with the given orientation angle containing
an ellipse.
|
| EllipseBoundingRectangle(Avl.Ellipse2D, Avl.Rectangle2D, Optional<Avl.Point2D>, Optional<float>, Optional<float>) |
Computes the smallest rectangle containing an ellipse.
|
| EllipseThroughFourPoints(Avl.Point2D, Avl.Point2D, Avl.Point2D, Avl.Point2D, Conditional<Avl.Ellipse2D>) |
Computes an ellipse passing through four noncollinear points.
|
| EllipseThroughThreePoints(Avl.Point2D, Avl.Point2D, Avl.Point2D, Conditional<Avl.Ellipse2D>) |
Computes an ellipse passing through three noncollinear points.
|
| EmptyImage(int, int, Avl.Pixel, int, Avl.PlainType, Avl.Image) |
Creates an image filled with one color.
|
| EmptyRegion(int, int, Avl.Region) |
Creates an empty region with a given frame.
|
| EnableAvlDiagnosticOutputs(bool) | |
| EnableAVX2Acceleration(bool) | |
| EnableGPUProcessing(bool) | |
| EnableNEONAcceleration(bool) | |
| EnableSSEAcceleration(bool) | |
| EndOAuthAuthorization(Avl.OAuthProvider, Optional<int>, Conditional<Avl.OAuthUser>, Conditional<string>) |
Waits until the verification flow is completed at the verification url. Once
the flow is ended, retrieves the information of the currently signed in OAuth
user.
|
| end(Avl.Point3DGrid) | |
| EnhanceMultipleObjectMatches(Avl.Image, List<Avl.Object2D>, List<List<Avl.Path>>, bool, List<Avl.Object2D>, List<List<Avl.Path>>) |
Improves accuracy of multiple object matching by adding a subpixel-precise adjustment.
|
| EnhanceSingleObjectMatch(Avl.Image, Avl.Object2D, List<Avl.Path>, bool, Avl.Object2D, List<Avl.Path>) |
Improves accuracy of single object matching by adding a subpixel-precise adjustment.
|
| EnlargeRegionNTimes(Avl.Region, int, Avl.Region) |
Enlarges a region by a natural factor.
|
| EnumerateImages_Random(Avl.EnumerateFilesRandomState, string, Optional<Avl.ImageFileFormat>, Optional<int>, bool, bool, bool, bool, int, Avl.Image, string, string, Optional<bool>, Optional<bool>) |
Scans a disk directory for image files and then returns the images one by one
in consecutive iterations sorted randomly.
|
| EnumerateImages(Avl.EnumerateFilesState, string, Optional<Avl.ImageFileFormat>, Avl.FileSortingOrder, bool, bool, bool, bool, int, Avl.Image, string, string, Optional<bool>, Optional<bool>) |
Scans a disk directory for image files and then returns the images one by one
in consecutive iterations sorted according to the specified order.
|
| EnumerateImageTiles(Avl.EnumerateImageTilesState, Avl.Image, int, Optional<int>, bool, int, Avl.Image, Optional<bool>, Optional<bool>, Diagnostic<Avl.Box>) |
Enumerates tiles from image.
|
| EqualizeImageHistogram(Avl.Image, Optional<Avl.Region>, float, float, Avl.Image) |
Maps image pixels to new values to achieve uniform distribution of intensities
in the range (0, 255).
|
| Equals(object) | Inherited from System.Object |
| ErodeBox(Avl.Box, int, Optional<int>, Avl.Box) |
Performs a morphological erosion on a box using box kernel.
|
| ErodeImage_AnyKernel(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, Optional<Avl.Pixel>, Avl.Region, Optional<Avl.Location>, Avl.Image) |
Replaces each pixel with the minimum of pixels within an arbitrary kernel.
|
| ErodeImage_Mask(Avl.Image, Optional<Avl.Region>, Avl.MorphologyKernel, Avl.Image) |
Replaces each pixel with the minimum of pixels within a small rectangular kernel.
|
| ErodeImage(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, Optional<Avl.Pixel>, Avl.KernelShape, int, Optional<int>, Avl.Image, Diagnostic<Avl.Region>) |
Replaces each pixel with the minimum of pixels within a kernel.
|
| ErodePolygon(Avl.Path, float, bool, Avl.Path) |
Shrinks a polygon by a given radius.
|
| ErodeProfile(Avl.Profile, Optional<Avl.Range>, int, bool, Avl.Profile) |
Changes a profile by choosing minimum point within a kernel.
|
| ErodeRegion_AnyKernel(Avl.Region, Avl.Region, Optional<Avl.Location>, Avl.Region) |
Performs a morphological erosion on a region using an arbitrary kernel.
|
| ErodeRegion_Threshold(Avl.Region, Avl.Region, Optional<Avl.Location>, int, Avl.Region) |
Erodes a region with inThresholdValue pixels of inKernel.
|
| ErodeRegion(Avl.Region, Avl.KernelShape, int, Optional<int>, Avl.Region) |
Performs a morphological erosion on a region using a predefined kernel.
|
| ErodeShapeRegion(Avl.ShapeRegion, float, Avl.ShapeRegion) |
Performs a morphological erosion on a shape region.
|
| ErodeSurfacePoints(Avl.Surface, Optional<Avl.Region>, Avl.KernelShape, int, Optional<int>, bool, Avl.Surface) |
Removes some existing points from the input surface when some points in their
vicinity are missing.
|
| EstimateAffine3DTransform(List<Avl.Point3D>, List<Avl.Point3D>, float, float, Avl.Matrix, List<int>, int) |
Computes optimal affine transformation between two 3D point sets.
|
| ExpaintImage_Bornemann(Avl.Image, Avl.Region, int, int, float, float, float, Avl.LuminanceMode, Avl.Image) |
Speculatively sets pixel values outside of a region using the fast marching
method and coherence analysis.
|
| ExpaintImage_Telea(Avl.Image, Avl.Region, int, int, Avl.Image) |
Speculatively sets pixel values outside of a region using the fast marching
method.
|
| ExpandRegions(List<Avl.Region>, Optional<Avl.Metric>, List<Avl.Region>) |
Splits pixels of the input regions and their complement among these regions.
|
| ExtendPath(Avl.Path, float, float) |
Resizes the first or the last segment of a path.
|
| ExtractBlobs_Color(Avl.Image, Optional<Avl.ShapeRegion>, Optional<Avl.CoordinateSystem2D>, Avl.ColorThresholdParams, Avl.PreSplitProcessingParams, Avl.SplittingParams, List<Avl.Region>, Avl.Region) |
Segments an image into blobs by color-based thresholding.
|
| ExtractBlobs_Dynamic(Avl.Image, Optional<Avl.ShapeRegion>, Optional<Avl.CoordinateSystem2D>, Avl.DynamicThresholdParams, Avl.PreSplitProcessingParams, Avl.SplittingParams, List<Avl.Region>, Avl.Region) |
Segments an image into blobs by dynamic thresholding.
|
| ExtractBlobs_Intensity(Avl.Image, Optional<Avl.ShapeRegion>, Optional<Avl.CoordinateSystem2D>, Avl.IntensityThresholdParams, Avl.PreSplitProcessingParams, Avl.SplittingParams, List<Avl.Region>, Avl.Region) |
Segments an image into blobs by thresholding using a single value.
|
| ExtractBlobs_Range(Avl.Image, Optional<Avl.ShapeRegion>, Optional<Avl.CoordinateSystem2D>, Avl.RangeThresholdParams, Avl.PreSplitProcessingParams, Avl.SplittingParams, List<Avl.Region>, Avl.Region) |
Segments an image into blobs by thresholding using a range of values.
|
| ExtractText2(Avl.Image, Avl.Rectangle2D, Avl.CoordinateSystem2D, Avl.Polarity, int, Optional<int>, Optional<int>, List<Avl.Region>, Diagnostic<List<Avl.Region>>) |
Ready-to-use tool for extracting and splitting text elements to single characters.
|
| ExtractText(Avl.Image, Avl.Rectangle2D, Avl.CoordinateSystem2D, Avl.TextSegmentation, List<Avl.Region>, Diagnostic<Avl.Region>, Diagnostic<List<Avl.Region>>, Diagnostic<Avl.Rectangle2D>) |
Ready-to-use tool for extracting and splitting character to single characters.
|
| FillImageBuffer(Avl.Image, int, int, Avl.PlainType, int, int, System.IntPtr) | |
| FillImagePreviewBuffer(Avl.Image, int, int, System.IntPtr, int, bool) | |
| FillImage(Avl.Image, Avl.Pixel) |
Fills the input image with one color.
|
| FillRegionHoles(Avl.Region, Avl.RegionConnectivity, int, Optional<int>, Avl.Region) |
Adds pixels to the input region so that it contains no holes.
|
| FilterGridPoints(List<Avl.Point2D>, Optional<int>, Optional<int>, float, Optional<float>, float, float, float, Optional<float>, Optional<float>, Optional<float>, List<Avl.Point2D>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<float>) |
Select a subset of the given points that forms a grid.
|
| FindClosestPoints(List<Avl.Point2D>, List<Avl.Point2D>, List<Avl.Point2D>, List<int>) |
For each given point, finds the closest point among the given point set.
|
| FindConnectedComponents(List<List<int>>, List<List<int>>, List<int>, bool) |
Finds connected components in a graph given as set of bidirectional connections.
|
| FindDataMode_FixedCount(List<float>, Optional<float>, Optional<float>, int, Optional<float>, float, float, float) |
Finds the mode in a set of data values by looking for highest concentration
of a fixed number of samples.
|
| FindDataMode_FixedSpread(List<float>, float, Optional<float>, float, float, int, float) |
Finds the mode in a set of data values by looking for highest number of samples
withing the specified spread.
|
| FindDataMode_MeanShift(List<float>, int, float, float) |
Finds the mode in a set of data values by iteratively computing its median.
|
| FindDensityMaxima_FixedCount(List<float>, int, Optional<float>, bool, Optional<float>, Avl.DataModeFunction, Optional<Avl.LocalBlindness>, List<float>, List<float>) |
Finds local density maxima in set of values by looking for the highest concentration
of a fixed number of samples.
|
| FindDensityMaxima_FixedSpread(List<float>, float, int, bool, Optional<float>, Avl.DataModeFunction, Optional<Avl.LocalBlindness>, List<float>, List<int>) |
Finds local density maxima in a set of values by looking for the highest number
of samples withing a range determined by the given spread.
|
| FindLongestSubpath(Avl.Path, float, Avl.Path) |
Creates a new path from the longest sequence of segments of the input path that
turn gently.
|
| FindMatchingRegions_IoU(List<Avl.Region>, List<int>, List<Avl.Region>, List<int>, double, List<Conditional<int>>, List<Conditional<Avl.Region>>, List<Conditional<double>>, Diagnostic<List<Conditional<double>>>) |
Finds corresponding regions in two arrays based on IoU value.
|
| FindMaxStableExtremalRegions(Avl.Image, int, int, int, float, float, Avl.RegionConnectivity, List<Avl.Region>) |
Segments an image by binarizing it with many different thresholds and by looking
which blobs appear "stable".
|
| FitArcToEdges_Direct(Avl.Image, Avl.ArcFittingField, Optional<Avl.CoordinateSystem2D>, int, int, Avl.SamplingParams, Avl.EdgeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, float, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Arc2D>, Optional<List<Conditional<Avl.Edge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.ArcFittingField>, Optional<List<Avl.Point2D>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series of 1D edge detections and finds an arc that best matches the
detected points.
|
| FitArcToEdges(Avl.Image, Avl.ArcFittingMap, Avl.EdgeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, float, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Arc2D>, Optional<List<Conditional<Avl.Edge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Point2D>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>) |
Performs a series of 1D edge detections and finds an arc that best matches the
detected points.
|
| FitArcToPath(Avl.Path, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Arc2D>) |
Approximates path by an arc using the selected outliers suppression method and
considering path's start and end.
|
| FitArcToPoints(List<Avl.Point2D>, Optional<Avl.Range>, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Arc2D>, Optional<List<Avl.Point2D>>) |
Approximates points with an arc using the selected outliers suppression method.
|
| FitArcToRidges_Direct(Avl.Image, Avl.ArcFittingField, Optional<Avl.CoordinateSystem2D>, int, int, Avl.SamplingParams, Avl.RidgeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, float, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Arc2D>, Optional<List<Conditional<Avl.Ridge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.ArcFittingField>, Optional<List<Avl.Point2D>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series of 1D ridge detections and finds an arc that best matches
the detected points.
|
| FitArcToRidges(Avl.Image, Avl.ArcFittingMap, Avl.RidgeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, float, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Arc2D>, Optional<List<Conditional<Avl.Ridge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Point2D>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>) |
Performs a series of 1D ridge detections and finds an arc that best matches
the detected points.
|
| FitArcToStripe_Direct(Avl.Image, Avl.ArcFittingField, Optional<Avl.CoordinateSystem2D>, int, int, Avl.SamplingParams, Avl.StripeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, float, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Arc2D>, Conditional<Avl.Arc2D>, Conditional<Avl.Arc2D>, Optional<List<Conditional<Avl.Stripe1D>>>, Optional<List<Avl.Point2D>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.ArcFittingField>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series of 1D stripe detections and finds an arc that best matches
the detected points.
|
| FitArcToStripe(Avl.Image, Avl.ArcFittingMap, Avl.StripeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, float, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Arc2D>, Conditional<Avl.Arc2D>, Conditional<Avl.Arc2D>, Optional<List<Conditional<Avl.Stripe1D>>>, Optional<List<Avl.Point2D>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>) |
Performs a series of 1D stripe detections and finds an arc that best matches
the detected points.
|
| FitCircle3DToHole(Avl.Point3DGrid, Optional<Avl.Region>, Avl.MEstimator, float, int, Optional<Avl.Plane3D>, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Circle3D>, Avl.Plane3D, Optional<List<Avl.Point3D>>, Optional<List<float>>, Optional<float>, Optional<float>, Optional<List<float>>, Optional<float>) |
Fits a circle to a hole in a plane.
|
| FitCircleToEdges3D_Direct(Avl.Surface, Avl.CircleFittingField, Optional<Avl.CoordinateSystem2D>, int, Optional<float>, int, Avl.InterpolationMethod, Avl.EdgeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, float, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Circle3D>, Optional<List<Conditional<Avl.SurfaceEdge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.CircleFittingField>, Optional<List<Avl.Point3D>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series of 1D edge detections in 3D and finds a circle that best matches
the detected points.
|
| FitCircleToEdges3D(Avl.Surface, Avl.CircleFittingMap, Avl.EdgeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, float, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Circle3D>, Optional<List<Conditional<Avl.SurfaceEdge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Point3D>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>) |
Performs a series of 1D edge detections and finds a circle that best matches
the detected points.
|
| FitCircleToEdges_Direct(Avl.Image, Avl.CircleFittingField, Optional<Avl.CoordinateSystem2D>, int, int, Avl.SamplingParams, Avl.EdgeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, float, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Circle2D>, Optional<List<Conditional<Avl.Edge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.CircleFittingField>, Optional<List<Avl.Point2D>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series of 1D edge detections and finds a circle that best matches
the detected points.
|
| FitCircleToEdges(Avl.Image, Avl.CircleFittingMap, Avl.EdgeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, float, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Circle2D>, Optional<List<Conditional<Avl.Edge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Point2D>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>) |
Performs a series of 1D edge detections and finds a circle that best matches
the detected points.
|
| FitCircleToPoints3D(List<Avl.Point3D>, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Optional<Avl.Plane3D>, Conditional<Avl.Circle3D>, Optional<List<Avl.Point3D>>) |
Approximates points in 3D with a circle using selected outliers suppression
method.
|
| FitCircleToPoints(List<Avl.Point2D>, Optional<Avl.Range>, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Circle2D>, Optional<List<Avl.Point2D>>) |
Approximates points with a circle using selected outliers suppression method.
|
| FitCircleToRidges3D_Direct(Avl.Surface, Avl.CircleFittingField, Optional<Avl.CoordinateSystem2D>, int, Optional<float>, int, Avl.InterpolationMethod, Avl.RidgeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, float, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Circle3D>, Optional<List<Conditional<Avl.SurfaceRidge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.CircleFittingField>, Optional<List<Avl.Point3D>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series of 1D ridge detections in 3D and finds a circle that best
matches the detected points.
|
| FitCircleToRidges3D(Avl.Surface, Avl.CircleFittingMap, Avl.RidgeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, float, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Circle3D>, Optional<List<Conditional<Avl.SurfaceRidge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Point3D>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>) |
Performs a series of 1D ridge detections and finds a circle that best matches
the detected points.
|
| FitCircleToRidges_Direct(Avl.Image, Avl.CircleFittingField, Optional<Avl.CoordinateSystem2D>, int, int, Avl.SamplingParams, Avl.RidgeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, float, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Circle2D>, Optional<List<Conditional<Avl.Ridge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.CircleFittingField>, Optional<List<Avl.Point2D>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series of 1D ridge detections and finds a circle that best matches
the detected points.
|
| FitCircleToRidges(Avl.Image, Avl.CircleFittingMap, Avl.RidgeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, float, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Circle2D>, Optional<List<Conditional<Avl.Ridge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Point2D>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>) |
Performs a series of 1D ridge detections and finds a circle that best matches
the detected points.
|
| FitCircleToStripe3D_Direct(Avl.Surface, Avl.CircleFittingField, Optional<Avl.CoordinateSystem2D>, int, Optional<float>, int, Avl.InterpolationMethod, Avl.StripeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, float, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Circle3D>, Conditional<Avl.Circle3D>, Conditional<Avl.Circle3D>, Optional<List<Conditional<Avl.SurfaceStripe1D>>>, Optional<List<Avl.Point3D>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.CircleFittingField>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series of 1D edge detections in 3D and finds a circle that best matches
the detected points.
|
| FitCircleToStripe3D(Avl.Surface, Avl.CircleFittingMap, Avl.StripeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, float, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Circle3D>, Conditional<Avl.Circle3D>, Conditional<Avl.Circle3D>, Optional<List<Conditional<Avl.SurfaceStripe1D>>>, Optional<List<Avl.Point3D>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>) |
Performs a series of 1D edge detections and finds a circle that best matches
the detected points.
|
| FitCircleToStripe_Direct(Avl.Image, Avl.CircleFittingField, Optional<Avl.CoordinateSystem2D>, int, int, Avl.SamplingParams, Avl.StripeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, float, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Circle2D>, Conditional<Avl.Circle2D>, Conditional<Avl.Circle2D>, Optional<List<Conditional<Avl.Stripe1D>>>, Optional<List<Avl.Point2D>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.CircleFittingField>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series 1D stripe detections and finds a circle that best matches
the detected points.
|
| FitCircleToStripe(Avl.Image, Avl.CircleFittingMap, Avl.StripeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, float, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Circle2D>, Conditional<Avl.Circle2D>, Conditional<Avl.Circle2D>, Optional<List<Conditional<Avl.Stripe1D>>>, Optional<List<Avl.Point2D>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>) |
Performs a series 1D stripe detections and finds a circle that best matches
the detected points.
|
| FitCircleToSurfaceHole(Avl.Surface, Optional<Avl.Region>, Avl.MEstimator, float, int, Optional<Avl.Plane3D>, Avl.CircleFittingMethod, Optional<Avl.MEstimator>, Conditional<Avl.Circle3D>, Avl.Plane3D, Optional<List<Avl.Point3D>>, Optional<List<float>>, Optional<float>, Optional<float>, Optional<List<float>>, Optional<float>) |
Fits a circle to a hole in a surface plane.
|
| FitLineToPoints3D_LTE(List<Avl.Point3D>, int, Optional<int>, Avl.Line3D, Optional<List<Avl.Point3D>>, Optional<float>, Diagnostic<int>) |
Approximates points in 3D with a line using Least Trimmed Error algorithm.
|
| FitLineToPoints3D_M(List<Avl.Point3D>, Avl.MEstimator, float, int, Optional<Avl.Line3D>, Avl.Line3D, Optional<List<Avl.Point3D>>) |
Approximates points in 3D with a line using selected M-estimator for outlier
suppression.
|
| FitLineToPoints3D_RANSAC(List<Avl.Point3D>, Optional<int>, float, Optional<int>, Conditional<Avl.Line3D>) |
Approximates points in 3D with a line using a RANSAC algorithm.
|
| FitLineToPoints3D(List<Avl.Point3D>, Avl.Line3D, Optional<float>) |
Approximates points in 3D with a line using the Least Squares method.
|
| FitLineToPoints_LTE(List<Avl.Point2D>, Optional<Avl.Range>, int, Optional<int>, Avl.Line2D, Optional<List<Avl.Point2D>>, Optional<float>, Diagnostic<int>) |
Approximates points with a line using Least Trimmed Error algorithm.
|
| FitLineToPoints_M(List<Avl.Point2D>, Optional<Avl.Range>, Avl.MEstimator, float, int, Optional<Avl.Line2D>, Avl.Line2D, Optional<List<Avl.Point2D>>) |
Approximates points with a line using selected M-estimator for outlier suppression.
|
| FitLineToPoints_RANSAC(List<Avl.Point2D>, Optional<Avl.Range>, Optional<int>, float, Optional<int>, Conditional<Avl.Line2D>) |
Approximates points with a line using a RANSAC algorithm.
|
| FitLineToPoints_TheilSen(List<Avl.Point2D>, Optional<Avl.Range>, Avl.TheilSenVariant, Optional<int>, Optional<float>, Avl.Line2D, Diagnostic<List<float>>) |
Approximates points with a line using TheilSen algorithm, optionally with Siegel's
improvement.
|
| FitLineToPoints(List<Avl.Point2D>, Optional<Avl.Range>, Avl.Line2D, Optional<float>) |
Approximates points with a line using the Least Squares method.
|
| FitPathToEdges3D_Direct(Avl.Surface, Avl.PathFittingField, Optional<Avl.CoordinateSystem2D>, Optional<float>, Optional<float>, int, Avl.InterpolationMethod, Avl.EdgeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, Optional<int>, Optional<float>, float, Conditional<List<Avl.Point3D>>, Optional<List<Conditional<Avl.SurfaceEdge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.PathFittingField>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Optional<Conditional<List<Avl.Segment3D>>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series of 1D edge detections in 3D and creates a path from the detected
points.
|
| FitPathToEdges3D(Avl.Surface, Avl.PathFittingMap, Avl.EdgeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, Optional<int>, Optional<float>, float, Conditional<List<Avl.Point3D>>, Optional<List<Conditional<Avl.SurfaceEdge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Optional<Conditional<List<Avl.Segment3D>>>) |
Performs a series of 1D edge detections and creates a path from the detected
points.
|
| FitPathToEdges_Direct(Avl.Image, Avl.PathFittingField, Optional<Avl.CoordinateSystem2D>, Optional<float>, int, Avl.SamplingParams, Avl.EdgeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, Optional<float>, float, Conditional<Avl.Path>, Optional<List<Conditional<Avl.Edge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.PathFittingField>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series of 1D edge detections and creates a path from the detected
points.
|
| FitPathToEdges(Avl.Image, Avl.PathFittingMap, Avl.EdgeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, Optional<float>, float, Conditional<Avl.Path>, Optional<List<Conditional<Avl.Edge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>) |
Performs a series of 1D edge detections and creates a path from the detected
points.
|
| FitPathToPath(Avl.Path, Avl.Path, Avl.PathOrientationAlignment, int, float, float, Avl.Path, Avl.CoordinateSystem2D, float) |
Rotates and shifts a path to minimize average distance between its points and
a reference path.
|
| FitPathToRidges3D_Direct(Avl.Surface, Avl.PathFittingField, Optional<Avl.CoordinateSystem2D>, Optional<float>, Optional<float>, int, Avl.InterpolationMethod, Avl.RidgeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, Optional<int>, Optional<float>, float, Conditional<List<Avl.Point3D>>, Optional<List<Conditional<Avl.SurfaceRidge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.PathFittingField>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Optional<Conditional<List<Avl.Segment3D>>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series of 1D ridge detections in 3D and creates a path from the detected
points.
|
| FitPathToRidges3D(Avl.Surface, Avl.PathFittingMap, Avl.RidgeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, Optional<int>, Optional<float>, float, Conditional<List<Avl.Point3D>>, Optional<List<Conditional<Avl.SurfaceRidge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Optional<Conditional<List<Avl.Segment3D>>>) |
Performs a series of 1D ridge detections and creates a path from the detected
points.
|
| FitPathToRidges_Direct(Avl.Image, Avl.PathFittingField, Optional<Avl.CoordinateSystem2D>, Optional<float>, int, Avl.SamplingParams, Avl.RidgeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, Optional<float>, float, Conditional<Avl.Path>, Optional<List<Conditional<Avl.Ridge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.PathFittingField>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series of 1D ridge detections and creates a path from the detected
points.
|
| FitPathToRidges(Avl.Image, Avl.PathFittingMap, Avl.RidgeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, Optional<float>, float, Conditional<Avl.Path>, Optional<List<Conditional<Avl.Ridge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>) |
Performs a series of 1D ridge detections and creates a path from the detected
points.
|
| FitPathToStripe3D_Direct(Avl.Surface, Avl.PathFittingField, Optional<Avl.CoordinateSystem2D>, Optional<float>, Optional<float>, int, Avl.InterpolationMethod, Avl.StripeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, Optional<int>, Optional<float>, float, Conditional<List<Avl.Point3D>>, Conditional<List<Avl.Point3D>>, Conditional<List<Avl.Point3D>>, Optional<List<Conditional<Avl.SurfaceStripe1D>>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.PathFittingField>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Optional<Conditional<List<Avl.Segment3D>>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series of 1D stripe detections in 3D and creates a path from the
detected points.
|
| FitPathToStripe3D(Avl.Surface, Avl.PathFittingMap, Avl.StripeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, Optional<int>, Optional<float>, float, Conditional<List<Avl.Point3D>>, Conditional<List<Avl.Point3D>>, Conditional<List<Avl.Point3D>>, Optional<List<Conditional<Avl.SurfaceStripe1D>>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Optional<Conditional<List<Avl.Segment3D>>>) |
Performs a series of 1D stripe detections and creates a path from the detected
points.
|
| FitPathToStripe_Direct(Avl.Image, Avl.PathFittingField, Optional<Avl.CoordinateSystem2D>, Optional<float>, int, Avl.SamplingParams, Avl.StripeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, Optional<float>, float, Conditional<Avl.Path>, Conditional<Avl.Path>, Conditional<Avl.Path>, List<Conditional<Avl.Stripe1D>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.PathFittingField>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series of 1D stripe detections and creates a path from the detected
points.
|
| FitPathToStripe(Avl.Image, Avl.PathFittingMap, Avl.StripeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, Optional<float>, float, Conditional<Avl.Path>, Conditional<Avl.Path>, Conditional<Avl.Path>, List<Conditional<Avl.Stripe1D>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>) |
Performs a series of 1D stripe detections and creates a path from the detected
points.
|
| FitPlaneToPoint3DGrid_M(Avl.Point3DGrid, Optional<Avl.Region>, Avl.MEstimator, float, int, Optional<Avl.Plane3D>, Avl.Plane3D, Optional<List<Avl.Point3D>>, Optional<List<float>>, Optional<float>, Optional<float>, Optional<List<float>>, Optional<float>) |
Approximates points of the input grid with a plane using selected M-estimator
for outlier suppression.
|
| FitPlaneToPoint3DGrid(Avl.Point3DGrid, Optional<Avl.Region>, Avl.Plane3D, Optional<List<float>>, Optional<float>, Optional<float>, Optional<List<float>>, Optional<float>) |
Approximates points of the input grid with a plane using the Least Squares method.
|
| FitPlaneToPoints_M(List<Avl.Point3D>, Avl.MEstimator, float, int, Optional<Avl.Plane3D>, Avl.Plane3D, Optional<List<Avl.Point3D>>, Optional<List<float>>, Optional<float>, Optional<float>, Optional<List<float>>, Optional<float>) |
Approximates points with a plane using selected M-estimator for outlier suppression.
|
| FitPlaneToPoints(List<Avl.Point3D>, Avl.Plane3D, Optional<List<float>>, Optional<float>, Optional<float>, Optional<List<float>>, Optional<float>) |
Approximates points with a plane using the Least Squares method.
|
| FitPlaneToSurface_M(Avl.Surface, Optional<Avl.Region>, Avl.MEstimator, float, int, Optional<Avl.Plane3D>, Avl.Plane3D, Optional<List<Avl.Point3D>>, Optional<List<float>>, Optional<float>, Optional<float>, Optional<List<float>>, Optional<float>) |
Approximates points of the input surface with a plane using selected M-estimator
for outlier suppression.
|
| FitPlaneToSurface(Avl.Surface, Optional<Avl.Region>, Avl.Plane3D, Optional<List<float>>, Optional<float>, Optional<float>, Optional<List<float>>, Optional<float>) |
Approximates points of the input surface with a plane using the Least Squares
method.
|
| FitSegmentToEdges3D_Direct(Avl.Surface, Avl.SegmentFittingField, Optional<Avl.CoordinateSystem2D>, int, Optional<float>, int, Avl.InterpolationMethod, Avl.EdgeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, float, Optional<Avl.MEstimator>, Conditional<Avl.Segment3D>, Optional<List<Conditional<Avl.SurfaceEdge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.SegmentFittingField>, Optional<List<Avl.Point3D>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series of 1D edge detections in 3D and finds a segment that best
matches the detected points.
|
| FitSegmentToEdges3D(Avl.Surface, Avl.SegmentFittingMap, Avl.EdgeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, float, Optional<Avl.MEstimator>, Conditional<Avl.Segment3D>, Optional<List<Conditional<Avl.SurfaceEdge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Point3D>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>) |
Performs a series of 1D edge detections and finds a segment that best matches
the detected points.
|
| FitSegmentToEdges_Direct(Avl.Image, Avl.SegmentFittingField, Optional<Avl.CoordinateSystem2D>, int, int, Avl.SamplingParams, Avl.EdgeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, float, Optional<Avl.LineMEstimator>, Conditional<Avl.Segment2D>, Optional<List<Conditional<Avl.Edge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.SegmentFittingField>, Optional<List<Avl.Point2D>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series of 1D edge detections and finds a segment that best matches
the detected points.
|
| FitSegmentToEdges(Avl.Image, Avl.SegmentFittingMap, Avl.EdgeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, float, Optional<Avl.LineMEstimator>, Conditional<Avl.Segment2D>, Optional<List<Conditional<Avl.Edge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Point2D>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>) |
Performs a series of 1D edge detections and finds a segment that best matches
the detected points.
|
| FitSegmentToPoints3D_LTE(List<Avl.Point3D>, int, Optional<int>, Avl.Segment3D, Optional<List<Avl.Point3D>>, Optional<float>, Diagnostic<int>) |
Approximates points in 3D with a segment using a RANSAC algorithm.
|
| FitSegmentToPoints3D_RANSAC(List<Avl.Point3D>, Optional<int>, float, Optional<int>, Conditional<Avl.Segment3D>) |
Approximates points in 3D with a segment using a RANSAC algorithm.
|
| FitSegmentToPoints3D(List<Avl.Point3D>, Optional<Avl.MEstimator>, Conditional<Avl.Segment3D>, Optional<List<Avl.Point3D>>) |
Approximates points in 3D with a segment using selected outliers suppression
method.
|
| FitSegmentToPoints_LTE(List<Avl.Point2D>, Optional<Avl.Range>, int, Optional<int>, Avl.Segment2D, Optional<List<Avl.Point2D>>, Optional<float>, Diagnostic<int>) |
Approximates points with a segment using Least Trimmed Error algorithm.
|
| FitSegmentToPoints_RANSAC(List<Avl.Point2D>, Optional<Avl.Range>, Optional<int>, float, Optional<int>, Conditional<Avl.Segment2D>) |
Approximates points with a segment using a RANSAC algorithm.
|
| FitSegmentToPoints_TheilSen(List<Avl.Point2D>, Optional<Avl.Range>, Avl.TheilSenVariant, Optional<int>, Optional<float>, Avl.Segment2D, Diagnostic<List<float>>) |
Approximates points with a segment using TheilSen algorithm, optionally with
Siegel's improvement.
|
| FitSegmentToPoints(List<Avl.Point2D>, Optional<Avl.Range>, Optional<Avl.MEstimator>, Avl.Segment2D, Optional<List<Avl.Point2D>>) |
Approximates points with a segment using selected outliers suppression method.
|
| FitSegmentToRegion(Avl.Region, Avl.RegionSegmentFittingMethod, Avl.Segment2D) |
Approximates a region with a segment using selected outliers suppression method.
|
| FitSegmentToRidges3D_Direct(Avl.Surface, Avl.SegmentFittingField, Optional<Avl.CoordinateSystem2D>, int, Optional<float>, int, Avl.InterpolationMethod, Avl.RidgeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, float, Optional<Avl.MEstimator>, Conditional<Avl.Segment3D>, Optional<List<Conditional<Avl.SurfaceRidge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.SegmentFittingField>, Optional<List<Avl.Point3D>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series of 1D ridge detections in 3D and finds a segment that best
matches the detected points.
|
| FitSegmentToRidges3D(Avl.Surface, Avl.SegmentFittingMap, Avl.RidgeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, float, Optional<Avl.MEstimator>, Conditional<Avl.Segment3D>, Optional<List<Conditional<Avl.SurfaceRidge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Point3D>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>) |
Performs a series of 1D ridge detections and finds a segment that best matches
the detected points.
|
| FitSegmentToRidges_Direct(Avl.Image, Avl.SegmentFittingField, Optional<Avl.CoordinateSystem2D>, int, int, Avl.SamplingParams, Avl.RidgeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, float, Optional<Avl.LineMEstimator>, Conditional<Avl.Segment2D>, Optional<List<Conditional<Avl.Ridge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.SegmentFittingField>, Optional<List<Avl.Point2D>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series of 1D ridge detections and finds a segment that best matches
the detected points.
|
| FitSegmentToRidges(Avl.Image, Avl.SegmentFittingMap, Avl.RidgeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, float, Optional<Avl.LineMEstimator>, Conditional<Avl.Segment2D>, Optional<List<Conditional<Avl.Ridge1D>>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Point2D>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>) |
Performs a series of 1D ridge detections and finds a segment that best matches
the detected points.
|
| FitSegmentToStripe3D_Direct(Avl.Surface, Avl.SegmentFittingField, Optional<Avl.CoordinateSystem2D>, int, Optional<float>, int, Avl.InterpolationMethod, Avl.StripeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, float, Optional<Avl.MEstimator>, Conditional<Avl.Segment3D>, Conditional<Avl.Segment3D>, Conditional<Avl.Segment3D>, Optional<List<Conditional<Avl.SurfaceStripe1D>>>, Optional<List<Avl.Point3D>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.SegmentFittingField>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series of 1D edge detections in 3D and finds a segment that best
matches the detected points.
|
| FitSegmentToStripe3D(Avl.Surface, Avl.SegmentFittingMap, Avl.StripeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, float, Optional<Avl.MEstimator>, Conditional<Avl.Segment3D>, Conditional<Avl.Segment3D>, Conditional<Avl.Segment3D>, Optional<List<Conditional<Avl.SurfaceStripe1D>>>, Optional<List<Avl.Point3D>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>) |
Performs a series of 1D edge detections and finds a segment that best matches
the detected points.
|
| FitSegmentToStripe_Direct(Avl.Image, Avl.SegmentFittingField, Optional<Avl.CoordinateSystem2D>, int, int, Avl.SamplingParams, Avl.StripeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, float, Optional<Avl.LineMEstimator>, Conditional<Avl.Segment2D>, Conditional<Avl.Segment2D>, Conditional<Avl.Segment2D>, Optional<List<Conditional<Avl.Stripe1D>>>, Optional<List<Avl.Point2D>>, Optional<Conditional<Avl.Profile>>, Optional<Avl.SegmentFittingField>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>) |
Performs a series of 1D stripe detections and finds a segment that best matches
the detected points.
|
| FitSegmentToStripe(Avl.Image, Avl.SegmentFittingMap, Avl.StripeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, float, Optional<Avl.LineMEstimator>, Conditional<Avl.Segment2D>, Conditional<Avl.Segment2D>, Conditional<Avl.Segment2D>, Optional<List<Conditional<Avl.Stripe1D>>>, Optional<List<Avl.Point2D>>, Optional<Conditional<Avl.Profile>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>) |
Performs a series of 1D stripe detections and finds a segment that best matches
the detected points.
|
| FlattenSurface_WithScalePreserving(Avl.Surface, Avl.Axis, float, Avl.Point3DGrid, Diagnostic<Avl.Surface>) |
Flattens a curved surface preserving the scale on the axes.
|
| FlattenSurface(Avl.Surface, Avl.Axis, float, Avl.Surface, Diagnostic<Avl.Surface>) |
Flattens a curved surface.
|
| FormatLocationToString(Avl.Location, int, string, bool, string, int, bool, string) |
Converts a location to a string of format "(X, Y)".
|
| FormatPoint2DToString(Avl.Point2D, int, int, string, string, bool, string, bool, string) |
Converts a 2D point to a string of format "(X, Y)".
|
| FormatPoint3DToString(Avl.Point3D, int, int, string, string, bool, string, bool, string) |
Converts a 3D point to a string of format "(X, Y, Z)".
|
| FourierTransform(Avl.Image, Avl.Image) |
Transforms an image into frequency domain using Fourier transformation.
|
| FrequencyDomain_FilterFrequencies(Avl.Image, Optional<float>, Optional<float>, Avl.Image) |
Filters the frequencies in a frequency domain image suppressing the elements
of too low or too high frequency.
|
| FrequencyDomain_ModulusImage(Avl.Image, Avl.Image) |
Computes the modulus of each frequency domain image pixel.
|
| FrequencyDomain_PhaseImage(Avl.Image, Avl.Image) |
Computes the phase of each frequency domain image pixel.
|
| Ftp_ReceiveFile(string, string, string, Optional<string>, Optional<string>, bool, Optional<int>, bool, Optional<string>) |
Downloads a file from a remote server using FTP (File Transfer Protocol).
|
| Ftp_ReceiveImage(string, string, Optional<string>, Optional<string>, bool, Optional<int>, bool, Optional<string>, bool, Avl.Image) |
Downloads an image from a remote server using FTP (File Transfer Protocol).
|
| Ftp_ReceiveString(string, string, Optional<string>, Optional<string>, bool, Optional<int>, bool, Optional<string>, string) |
Downloads a text string from a remote server using FTP (File Transfer Protocol).
|
| Ftp_SendFile(string, string, string, Optional<string>, Optional<string>, bool, Optional<int>, bool, Optional<string>) |
Sends a file to a remote server using FTP (File Transfer Protocol).
|
| Ftp_SendImage(Avl.Image, Optional<Avl.ImageFileFormat>, string, string, Optional<string>, Optional<string>, bool, Optional<int>, bool, Optional<string>) |
Sends an image to a remote server using FTP (File Transfer Protocol).
|
| Ftp_SendString(string, string, string, Optional<string>, Optional<string>, bool, Optional<int>, bool, Optional<string>) |
Sends a string to a remote serve using FTP (File Transfer Protocol).
|
| Gap1DToSegment2D(Avl.Gap1D, Avl.Segment2D) |
Converts a gap to a segment.
|
| GenerateCalibrationPoints(int, int, float, Avl.Vector3D, float, Avl.Vector3D, Avl.CameraModelType, float, Optional<float>, Optional<Avl.Point2D>, Avl.Size, List<Avl.AnnotatedPoint2D>, List<Avl.Point2D>) |
Generates artificial points for camera calibration. Doesn't support distortion.
|
| GenerateDatamatrixCode(string, int, int, Avl.Image) |
Generates datamatrix code
|
| GetAvailableLicenses(List<Avl.License>) |
Reads available licenses in the system.
|
| GetAvailableVideoCompressors(List<string>) |
Lists FourCC names of available video compressors.
|
| GetAvlDiagnosticOutputsEnabled() | |
| GetAVX2AccelerationEnabled() | |
| GetComputerID(string) |
Gets current Computer ID.
|
| GetDongleSerialNumber(string) |
Gets the current usb dongle's serial number.
|
| GetGPUProcessingDiagInfo(string) | |
| GetHashCode() | Inherited from System.Object |
| GetHistogramBin(Avl.Histogram, int, bool, bool, double, Optional<float>, Optional<float>) |
Returns the value of a single histogram bin.
|
| GetHistogramCorrespondingBin(Avl.Histogram, float, bool, double) |
Selects a bin that the given value in the histogram domain falls into and returns
the value of this bin.
|
| GetImageColumn(Avl.Image, Optional<int>, int, List<float>, List<Avl.Pixel>) |
Extracts an array of pixel values from a single column of an image.
|
| GetImageData(Avl.Image, Optional<int>, Avl.ByteBuffer) |
Extracts the image content (raw pixel data) as a binary buffer.
|
| GetImagePixel_Interpolated(Avl.Image, Avl.Point2D, Avl.InterpolationMethod, Avl.Pixel, float) |
Returns an interpolated single pixel of an image.
|
| GetImagePixel(Avl.Image, Avl.Location, Avl.Pixel, float) |
Returns a single pixel of an image.
|
| GetImageRow(Avl.Image, Optional<int>, int, List<float>, List<Avl.Pixel>) |
Extracts an array of pixel values from a single row of an image.
|
| GetLibraryVersion(int, int, int, int) |
Gets current library version.
|
| GetMaximumPath_OrNil(List<Avl.Path>, Avl.PathFeature, Conditional<Avl.Path>, Conditional<float>, Conditional<int>) |
Returns the path from the input array that corresponds to the largest computed
feature value; returns NIL if the array or any path inside it is empty.
|
| GetMaximumPath(List<Avl.Path>, Avl.PathFeature, Avl.Path, Optional<float>, Optional<int>) |
Returns the path from the input array that corresponds to the largest computed
feature value.
|
| GetMaximumRegion_OrNil(List<Avl.Region>, Avl.RegionFeature, Conditional<Avl.Region>, Conditional<float>, Conditional<int>) |
Returns the region from the input array that corresponds to the largest computed
feature value; returns NIL if the array or any region inside it is empty.
|
| GetMaximumRegion(List<Avl.Region>, Avl.RegionFeature, Avl.Region, Optional<float>, Optional<int>) |
Returns the region from the input array that corresponds to the largest computed
feature value.
|
| GetMinimumPath_OrNil(List<Avl.Path>, Avl.PathFeature, Conditional<Avl.Path>, Conditional<float>, Conditional<int>) |
Returns the path from the input array that corresponds to the smallest computed
feature value; returns NIL if the array or any path inside it is empty.
|
| GetMinimumPath(List<Avl.Path>, Avl.PathFeature, Avl.Path, Optional<float>, Optional<int>) |
Returns the path from the input array that corresponds to the smallest computed
feature value.
|
| GetMinimumRegion_OrNil(List<Avl.Region>, Avl.RegionFeature, Conditional<Avl.Region>, Conditional<float>, Conditional<int>) |
Returns the region from the input array that corresponds to the smallest computed
feature value; returns NIL if the array or any region inside it is empty.
|
| GetMinimumRegion(List<Avl.Region>, Avl.RegionFeature, Avl.Region, Optional<float>, Optional<int>) |
Returns the region from the input array that corresponds to the smallest computed
feature value.
|
| GetMultipleImagePixelValues_Safe(Avl.Image, List<Avl.Point2D>, Avl.InterpolationMethod, float, List<float>) |
Returns an array of pixel values at specified locations; the image range is
checked.
|
| GetNEONAccelerationEnabled() | |
| GetParallelComputingThreadsCount() | |
| GetPathCharacteristicPoint_Interpolated(Avl.Path, float, Avl.Point2D) |
Returns linear interpolation between two consecutive characteristic points of
a path.
|
| GetPathCharacteristicPoint(Avl.Path, int, bool, Avl.Point2D) |
Returns the selected characteristic point of a path.
|
| GetPathSegment(Avl.Path, int, bool, Avl.Segment2D) |
Returns the selected segment of a path.
|
| GetPoint3DGridPoint_Interpolated(Avl.Point3DGrid, float, float, float, float, float, float, int, Avl.Point3D) |
Returns an interpolated single point of a point 3D grid.
|
| GetPointOnPath(Avl.Path, float, Avl.Point2D) |
Returns a path point of desired distance (measured along path) from the first
point of the path.
|
| GetProfileElement_Interpolated(Avl.Profile, bool, bool, float, float) |
Gets a single value from a profile, interpolated at any point.
|
| GetProfileElement(Avl.Profile, int, bool, float) |
Gets a single value from a profile, located at the specified index.
|
| GetProfileValue(Avl.Profile, float, bool, float) |
Gets a single value from a profile, located at the specified X (real-world)
coordinate.
|
| GetRegionFrame(Avl.Region, int, int) |
Returns the width and height of the entire region's frame (not to be confused
with RegionBoundingBox!).
|
| GetSSEAccelerationEnabled() | |
| GetSurfaceElement_Interpolated(Avl.Surface, Avl.Point2D, int, Avl.Point3D) |
Returns an interpolated single point of a surface given its surface grid coordinates.
|
| GetSurfacePath(Avl.Surface, Avl.Path, Avl.Path) |
Returns a path consisting of interpolated single points of a surface given their
surface grid coordinates.
|
| GetTensorDataOrderingDimensionality(Avl.TensorDataOrdering) | |
| GetThreadLimitInfo(Conditional<int>, List<string>) |
Returns how many threads are possible and a list of threads currently being
used.
|
| GetType() | Inherited from System.Object |
| GoldenTemplate3D(Avl.Point3DGrid, Avl.Point3DGrid, float, float, int, int, float, Optional<Avl.TransformLimits3D>, bool, Optional<float>, float, List<Avl.Point3D>, List<Avl.Point3D>, Avl.Matrix, Diagnostic<Avl.Point3DGrid>, Diagnostic<Avl.Point3DGrid>) |
Compares points on the input with the golden object. Any significant differences
are considered defects.
|
| GrabImage_FromFiles_ResetState() |
Resets the global state of GrabImage_FromFiles filter.
|
| GrabImage_FromFiles(string, Optional<Avl.ImageFileFormat>, Avl.FileSortingOrder, bool, bool, bool, bool, int, Avl.Image, string, string) |
Simulates capturing a frame from a camera.
|
| GradientDirAndPresenceImage(Avl.Image, Optional<Avl.Region>, Avl.GradientMaskOperator, float, Avl.AngleRange, Avl.Image) |
Computes an image of gradient directions mapped to the range from 1 to 255.
Zero means "no edge".
|
| GradientImageRidges_Sparse(Avl.Image, Avl.Image, int, Avl.SparseImage) |
Finds ridge pixels in a gradient image.
|
| GradientImageRidges(Avl.Image, Optional<Avl.Region>, Avl.GradientMaskOperator, Avl.MagnitudeMeasure, Avl.NonMaximaMethod, int, Avl.Region, Avl.Image) |
Finds ridge pixels in a gradient image.
|
| GradientImage_Mask(Avl.Image, Optional<Avl.Region>, Avl.GradientMaskOperator, int, Avl.Image, Diagnostic<Avl.Image>) |
Computes a gradient image with a Sobel or Prewitt operator.
|
| GradientImage(Avl.Image, Optional<Avl.Region>, Avl.GradientOperator, float, Optional<float>, Avl.Image, Diagnostic<Avl.Image>) |
Computes a gradient image with smoothing operator of any size. The output pixels
are signed.
|
| GradientMagnitudeImage_Signed(Avl.Image, Avl.EdgeTransition, Avl.DifferentiationMethod, Avl.GradientOrientation, bool, Avl.Image) |
Computes an image of gradient for only selected direction.
|
| GradientMagnitudeImage(Avl.Image, Optional<Avl.Region>, Avl.GradientMaskOperator, Avl.MagnitudeMeasure, int, Avl.Image) |
Measures the strength of gradient at each pixel location.
|
| GrayModel2ByteSize(Avl.GrayModel2, long) |
Returns estimated size of the GrayModel2 in bytes.
|
| GroupPathsByRegions(List<Avl.Path>, List<Avl.Region>, Avl.MatchingCriterion, List<List<int>>, Optional<List<List<Avl.Path>>>) |
For each region returns which paths lie inside of it or intersect with it.
|
| GroupPointsByRegions(List<Avl.Point2D>, List<Avl.Region>, List<List<int>>, Optional<List<List<Avl.Point2D>>>) |
For each region returns which points lie inside of it.
|
| GroupRegionsByLines(List<Avl.Region>, Avl.Rectangle2D, Optional<Avl.CoordinateSystem2D>, int, float, bool, List<List<Avl.Region>>, List<Avl.Region>, List<Avl.Region>, List<Avl.Region>, List<Avl.Region>, Avl.Rectangle2D, Diagnostic<List<Avl.Segment2D>>, Diagnostic<List<Avl.Rectangle2D>>, Diagnostic<List<Avl.Point2D>>) |
Splits an array of blobs by distance to computed base lines.
|
| GroupRegionsByRegions(List<Avl.Region>, List<Avl.Region>, Avl.MatchingCriterion, List<List<int>>, Optional<List<List<Avl.Region>>>) |
For each region returns which regions lie inside of it or intersect with it.
|
| HeatmapToImage(Avl.Heatmap, Avl.Image) |
Converts a heatmap to an image.
|
| HistogramAverage(Avl.Histogram, double) |
Computes the average of histogram bin values.
|
| HistogramDataAverage(Avl.Histogram, float) |
Computes the average of the histogrammed numeric data.
|
| HistogramDataMaximum(Avl.Histogram, float) |
Computes the approximation of the largest value of the histogrammed numeric
data.
|
| HistogramDataMedian(Avl.Histogram, float) |
Computes the median of the histogrammed numeric data.
|
| HistogramDataMinimum(Avl.Histogram, float) |
Computes the approximation of the smallest value of the histogrammed numeric
data.
|
| HistogramDataNthValue(Avl.Histogram, double, Avl.SortingOrder, float) |
Computes nth smallest (or largest) value of the histogrammed numeric data.
|
| HistogramDataQuantile(Avl.Histogram, float, float) |
Computes the specified quantile of the histogrammed numeric data.
|
| HistogramDataSize(Avl.Histogram, double) |
Computes the number of elements of the histogrammed numeric data.
|
| HistogramDataStandardDeviation(Avl.Histogram, float) |
Computes the standard deviation of the histogrammed numeric data.
|
| HistogramDataVariance(Avl.Histogram, float) |
Computes the variance of the histogrammed numeric data.
|
| HistogramDistance(Avl.Histogram, Avl.Histogram, Avl.DistanceMeasure, double) |
Computes the numeric distance between two histograms.
|
| HistogramIndices(Avl.Histogram, List<int>) |
Returns an array of histogram elements' indices.
|
| HistogramIntersection(Avl.Histogram, Avl.Histogram, double) |
Calculates normalized histogram intersection norm.
|
| HistogramLocalExtrema(Avl.Histogram, Optional<Avl.Range>, Optional<double>, Optional<double>, bool, bool, Avl.ExtremumType, Avl.HistogramInterpolationMethod, Optional<Avl.LocalBlindness>, List<Avl.HistogramExtremum>) |
Computes the histogram local extrema.
|
| HistogramMaximum(Avl.Histogram, Optional<Avl.Range>, Avl.HistogramInterpolationMethod, int, float, double) |
Computes histogram bar values maximum - its location and value.
|
| HistogramMinimum(Avl.Histogram, Optional<Avl.Range>, Avl.HistogramInterpolationMethod, int, float, double) |
Computes histogram bar values minimum - its location and value.
|
| HistogramSize(Avl.Histogram, int) |
Computes the number of histogram bins.
|
| HistogramSum(Avl.Histogram, double) |
Computes the sum of histogram bin values.
|
| HsiToRgb(Avl.Image, Avl.Image) |
Converts color space from Hue-Saturation-Intensity into Red-Green-Blue.
|
| HslToRgb(Avl.Image, Avl.Image) |
Converts color space from Hue-Saturation-Luminance to Red-Green-Blue.
|
| HsvToRgb(Avl.Image, Avl.Image) |
Converts color space from Hue-Saturation-Value to Red-Green-Blue.
|
| Http_DecodeURL(string, string) |
Converts text from URL friendly text to a string.
|
| Http_EncodeURL(string, string) |
Converts string to URL friendly text.
|
| Http_SendBinaryData(string, List<string>, List<string>, Avl.ByteBuffer, int, bool, Optional<string>, Conditional<Avl.ByteBuffer>, int) |
Sends a raw HTTP request.
|
| Http_SendCustomRequest(Avl.HTTPRequestMethod, string, List<string>, List<string>, List<string>, List<string>, Avl.ByteBuffer, int, bool, Optional<string>, Conditional<Avl.ByteBuffer>, int) |
Sends a custom HTTP request.
|
| Http_SendRequest_DELETE_ByteBuffer(string, List<string>, List<string>, List<string>, List<string>, int, bool, Optional<string>, Conditional<Avl.ByteBuffer>, int) |
Sends a DELETE request to server and receives a binary answer.
|
| Http_SendRequest_DELETE(string, List<string>, List<string>, List<string>, List<string>, int, bool, Optional<string>, Conditional<string>, int) |
Sends a DELETE request to server and receives a text answer.
|
| Http_SendRequest_GET_ByteBuffer(string, List<string>, List<string>, List<string>, List<string>, int, bool, Optional<string>, Conditional<Avl.ByteBuffer>, int) |
Sends a GET request to server and receives a binary answer.
|
| Http_SendRequest_GET(string, List<string>, List<string>, List<string>, List<string>, int, bool, Optional<string>, Conditional<string>, int) |
Sends a GET request to server and receives a text answer.
|
| Http_SendRequest_PATCH_ByteBuffer(string, List<string>, List<string>, List<string>, List<string>, int, bool, Optional<string>, Conditional<Avl.ByteBuffer>, int) |
Sends a PATCH request to the server and receives a text answer.
|
| Http_SendRequest_PATCH_JSON(string, List<string>, List<string>, string, int, bool, Optional<string>, Conditional<string>, int) |
Sends a PATCH request in JSON format to the server and receives a text answer.
|
| Http_SendRequest_PATCH(string, List<string>, List<string>, List<string>, List<string>, int, bool, Optional<string>, Conditional<string>, int) |
Sends a PATCH request to the server and receives a text answer.
|
| Http_SendRequest_POST_ByteBuffer(string, List<string>, List<string>, List<string>, List<string>, int, bool, Optional<string>, Conditional<Avl.ByteBuffer>, int) |
Sends a POST request to the server and receives a text answer.
|
| Http_SendRequest_POST_JSON(string, List<string>, List<string>, string, int, bool, Optional<string>, Conditional<string>, int) |
Sends a POST request in JSON format to the server and receives a text answer.
|
| Http_SendRequest_POST(string, List<string>, List<string>, List<string>, List<string>, int, bool, Optional<string>, Conditional<string>, int) |
Sends a POST request to the server and receives a text answer.
|
| Http_SendRequest_PUT_ByteBuffer(string, List<string>, List<string>, List<string>, List<string>, int, bool, Optional<string>, Conditional<Avl.ByteBuffer>, int) |
Sends a PUT request to the server and receives a text answer.
|
| Http_SendRequest_PUT_JSON(string, List<string>, List<string>, string, int, bool, Optional<string>, Conditional<string>, int) |
Sends a PUT request in JSON format to the server and receives a text answer.
|
| Http_SendRequest_PUT(string, List<string>, List<string>, List<string>, List<string>, int, bool, Optional<string>, Conditional<string>, int) |
Sends a PUT request to the server and receives a text answer.
|
| ImageAlongArc(Avl.Image, Avl.Arc2D, Optional<Avl.CoordinateSystem2D>, int, Avl.Axis, Avl.InterpolationMethod, Optional<Avl.Pixel>, Avl.Image, Optional<Avl.Arc2D>, Diagnostic<List<Avl.Path>>) |
Creates an image from pixels traversed along an arc.
|
| ImageAlongPath(Avl.Image, Avl.Path, Optional<Avl.CoordinateSystem2D>, int, Avl.Axis, Avl.InterpolationMethod, Optional<Avl.Pixel>, Avl.Image, Optional<Avl.Path>, Diagnostic<List<Avl.Path>>) |
Creates an image from pixels traversed along a path.
|
| ImageAverageHSx(Avl.Image, Optional<Avl.Region>, Avl.HSxColorModel, Optional<int>, int, int, int) |
Computes the average of the HSV, HSL or HSI image pixel values.
|
| ImageAverage(Avl.Image, Optional<Avl.Region>, Avl.Pixel, Optional<float>) |
Computes the average of the image pixel values.
|
| ImageBoxToSurfaceCoordinates(Avl.Box, Avl.SurfaceCoordinatesFormat, Avl.Box, Optional<Avl.Box3D>) |
Finds the surface coordinates of image box.
|
| ImageBox(Avl.Image, Avl.Box) |
Returns a box corresponding to the dimensions of an image.
|
| ImageCenter(Avl.Image, Avl.Point2D) |
Returns the geometrical center of an image.
|
| ImageCharacteristicPoint(Avl.Image, Avl.Anchor2D, Avl.Point2D) |
Returns one of the 9 characteristic points of an image (corners or mid-points).
|
| ImageCircleToSurfaceCoordinates(Avl.Circle2D, Avl.SurfaceCoordinatesFormat, Avl.Circle2D, Optional<Avl.Circle3D>) |
Finds the surface coordinates of image circle.
|
| ImageCoordinateSystemToSurfaceCoordinates(Avl.CoordinateSystem2D, Avl.SurfaceCoordinatesFormat, Avl.CoordinateSystem2D) |
Finds the surface coordinates of image coordinate system.
|
| ImageCorrelationImage(Avl.Image, Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, Avl.CorrelationMeasure, Avl.Image) |
Computes an image of correlation between a pattern and the input image at each
possible location.
|
| ImageCorrelation(Avl.Image, Avl.Image, Optional<Avl.Region>, Avl.CorrelationMeasure, float) |
Computes the correlation of pattern and image.
|
| ImageDifferenceImage(Avl.Image, Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, Avl.DistanceMeasure, Avl.Image) |
Computes an image of differences between a moving pattern and the input image.
|
| ImageDifference(Avl.Image, Avl.Image, Optional<Avl.Region>, Avl.DistanceMeasure, float) |
Measures dissimilarity between two images.
|
| ImageEdgesToWorldPlane(List<Avl.Edge1D>, Avl.RectificationTransform, List<Avl.Edge1D>) |
Finds the world coordinates of image Edges.
|
| ImageEdgeToWorldPlane(Avl.Edge1D, Avl.RectificationTransform, Avl.Edge1D) |
Finds the world coordinates of image Edge.
|
| ImageGapsToWorldPlane(List<Avl.Gap1D>, Avl.RectificationTransform, List<Avl.Gap1D>) |
Finds the world coordinates of image Gaps.
|
| ImageGapToWorldPlane(Avl.Gap1D, Avl.RectificationTransform, Avl.Gap1D) |
Finds the world coordinates of image Gap.
|
| ImageHistogram(Avl.Image, Optional<Avl.Region>, int, float, float, int, Avl.Histogram) |
Computes the histogram of the image pixel values.
|
| ImageInversePolarTransform(Avl.Image, Avl.Point2D, Avl.PolarSpaceType, Avl.PolarInterpolationMethod, Avl.Image) |
Transforms an image from polar or log-polar space to euclidean space.
|
| ImageLineToSurfaceCoordinates(Avl.Line2D, Avl.SurfaceCoordinatesFormat, Avl.Line2D, Optional<Avl.Line3D>) |
Finds the surface coordinates of image line.
|
| ImageLocalMaxima(Avl.Image, Optional<Avl.Region>, bool, Optional<float>, Optional<float>, float, Optional<Avl.ImageLocalExtremaVerification>, Optional<List<Avl.Extremum2D>>, Optional<List<Avl.Region>>) |
Finds image locations characterized by locally maximal pixel values.
|
| ImageLocalMinima(Avl.Image, Optional<Avl.Region>, bool, Optional<float>, Optional<float>, float, Optional<Avl.ImageLocalExtremaVerification>, Optional<List<Avl.Extremum2D>>, Optional<List<Avl.Region>>) |
Finds image locations characterized by locally minimal pixel values.
|
| ImageMassCenter(Avl.Image, Optional<Avl.Region>, Avl.Point2D) |
Computes a point with coordinates equal to image mass center in brightness scale.
|
| ImageMaximum(Avl.Image, Optional<Avl.Region>, Optional<Avl.Location>, Optional<float>) |
Finds the location and the value of the brightest pixel.
|
| ImageMinimum(Avl.Image, Optional<Avl.Region>, Optional<Avl.Location>, Optional<float>) |
Finds the location and the value of the darkest pixel.
|
| ImageMoment(Avl.Image, Optional<Avl.Region>, Avl.ImageMomentType, bool, float, Optional<float>) |
Computes the selected moment of an image in regular and normalized (divided
by sum of pixel values) variant.
|
| ImageOrientation(Avl.Image, Optional<Avl.Region>, float) |
Computes the orientation of an image using image moments. The result range is
from 0.0 to 180.0.
|
| ImagePathsToSurfaceCoordinates(List<Avl.Path>, Avl.SurfaceCoordinatesFormat, List<Avl.Path>) |
Finds the surface coordinates of image paths.
|
| ImagePathsToWorldPlane(List<Avl.Path>, Avl.RectificationTransform, List<Avl.Path>) |
Finds the world coordinates of image Paths.
|
| ImagePathToSurfaceCoordinates(Avl.Path, Avl.SurfaceCoordinatesFormat, Avl.Path) |
Finds the surface coordinates of image path.
|
| ImagePathToWorldPlane(Avl.Path, Avl.RectificationTransform, Avl.Path) |
Finds the world coordinates of image Path.
|
| ImagePixels(Avl.Image, Optional<Avl.Region>, List<Avl.Pixel>) |
Returns an array of pixels from the input image.
|
| ImagePixelValues(Avl.Image, Optional<Avl.Region>, List<float>) |
Returns an array of pixel values from the input image.
|
| ImagePointsToSurfaceCoordinates(List<Avl.Point2D>, Avl.SurfaceCoordinatesFormat, List<Avl.Point2D>) |
Finds the surface coordinates of image points.
|
| ImagePointsToWorldPlane(List<Avl.Point2D>, Avl.RectificationTransform, List<Avl.Point2D>) |
Finds the world coordinates of image Points.
|
| ImagePointToSurfaceCoordinates(Avl.Point2D, Avl.SurfaceCoordinatesFormat, Avl.Point2D, Optional<Avl.Point3D>) |
Finds the surface coordinates of image point.
|
| ImagePointToWorldPlane(Avl.Point2D, Avl.RectificationTransform, Avl.Point2D) |
Finds the world coordinates of image Point.
|
| ImagePolarTransform(Avl.Image, Avl.Point2D, Avl.PolarSpaceType, Avl.PolarInterpolationMethod, Avl.Image) |
Transforms an image to polar or log-polar space.
|
| ImageProfileAlongPath(Avl.ScanMapState, Avl.Image, Avl.Path, Optional<Avl.CoordinateSystem2D>, int, Avl.SamplingParams, float, Avl.AccumulationMode, Optional<Avl.Pixel>, Avl.Profile, Avl.Path, Optional<Avl.Path>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Creates a series of segments across the input path, measures the average pixel
intensity on each of the segments, and creates the final profile from those
values.
|
| ImageProjection(Avl.Image, Optional<Avl.Region>, Avl.ProjectionDirection, Avl.ProjectionMode, Avl.Profile) |
Computes the average (or other statistic) for each image row or column and then
merges the obtained results into a profile.
|
| ImageRidgesToWorldPlane(List<Avl.Ridge1D>, Avl.RectificationTransform, List<Avl.Ridge1D>) |
Finds the world coordinates of image Ridges.
|
| ImageRidges(Avl.Image, Optional<Avl.Region>, Avl.Polarity, Optional<float>, Optional<float>, float, Avl.Region) |
Finds ridge pixels in an image.
|
| ImageRidgeToWorldPlane(Avl.Ridge1D, Avl.RectificationTransform, Avl.Ridge1D) |
Finds the world coordinates of image Ridge.
|
| ImageSegmentsToSurfaceCoordinates(List<Avl.Segment2D>, Avl.SurfaceCoordinatesFormat, List<Avl.Segment2D>) |
Finds the surface coordinates of image segments.
|
| ImageSegmentsToWorldPlane(List<Avl.Segment2D>, Avl.RectificationTransform, List<Avl.Segment2D>) |
Finds the world coordinates of image Segments.
|
| ImageSegmentToSurfaceCoordinates(Avl.Segment2D, Avl.SurfaceCoordinatesFormat, Avl.Segment2D, Optional<Avl.Segment3D>) |
Finds the surface coordinates of image segment.
|
| ImageSegmentToWorldPlane(Avl.Segment2D, Avl.RectificationTransform, Avl.Segment2D) |
Finds the world coordinates of image Segment.
|
| ImageSharpness(Avl.Image, Optional<Avl.Box>, float) |
Returns a value dependent on sharpness of the image. The value is bigger for
sharper images.
|
| ImageStandardDeviation(Avl.Image, Optional<Avl.Region>, float) |
Calculates standard deviation of image pixel values.
|
| ImageStatistics(Avl.Image, Optional<Avl.Region>, Optional<Avl.Location>, Optional<float>, Optional<Avl.Location>, Optional<float>, Optional<Avl.Pixel>, Optional<float>, Optional<Avl.Pixel>, Optional<float>) |
Computes various statistics of the image pixel values.
|
| ImageStripesToWorldPlane(List<Avl.Stripe1D>, Avl.RectificationTransform, List<Avl.Stripe1D>) |
Finds the world coordinates of image Stripes.
|
| ImageStripeToWorldPlane(Avl.Stripe1D, Avl.RectificationTransform, Avl.Stripe1D) |
Finds the world coordinates of image Stripe.
|
| ImageSum(Avl.Image, Optional<Avl.Region>, Avl.Pixel, Optional<float>) |
Computes the sum of the image pixel values.
|
| ImageToImageFormat(Avl.Image, Avl.ImageFormat) |
Converts an image to an image format.
|
| ImageToMatrix(Avl.Image, Avl.Matrix) |
Converts a single-channel image to a matrix.
|
| ImageToSize(Avl.Image, Avl.Size) |
Converts an image to a size.
|
| ImageVectorToSurfaceCoordinates(Avl.Vector2D, Avl.SurfaceCoordinatesFormat, Avl.Vector2D, Optional<Avl.Vector3D>) |
Finds the surface coordinates of image vector.
|
| InflatePath(Avl.Path, float, float, Conditional<Avl.Path>) |
Enlarges a path by a given margin (points in the input path must be sorted clockwise).
|
| InflateRectangle(Avl.Rectangle2D, float, Avl.Rectangle2D) |
Enlarges a rectangle by a given margin.
|
| InitGPUProcessing(string, string) | |
| InitLibrary() |
Initializes library internals. Should be called before any other function from
AVL.
|
| InitOAuth_Google(string, string, Optional<List<string>>) |
Sets up the OAuth 2.0 framework for Google Authorization.
|
| InitOAuth_Microsoft(string, string, Optional<List<string>>) |
Sets up the OAuth 2.0 framework for Microsoft Authorization.
|
| InpaintImage_Bornemann(Avl.Image, Avl.Region, int, float, float, float, Avl.LuminanceMode, Avl.Image) |
Fills in a region of an image with pixel values interpolated from the borders
of the area; uses fast marching method and coherence analysis.
|
| InpaintImage_Telea(Avl.Image, Avl.Region, int, Avl.Image) |
Fills in a region of an image with pixel values interpolated from the borders
of the area; uses fast marching method.
|
| InpaintImage(Avl.Image, float, Avl.ShapeRegion, Optional<Avl.CoordinateSystem2D>) |
Fills in a region of an image with pixel values interpolated from the borders
of the area.
|
| InscribeRegionInRegion(Avl.Region, Avl.Region, Avl.ShiftType, Avl.FitType, Conditional<int>, Conditional<int>, Conditional<Avl.Region>) |
Shifts source region so that it is contained in target region.
|
| InsertToPath(Avl.Path, Avl.Point2D, int, bool) |
Inserts a new point to a path at a specified location.
|
| InspectImageMemoryPools(bool, List<int>, List<int>, int) |
Returns information about allocated image memory buffers. This information can
be used for preallocation.
|
| IntegerToHash(int, Avl.Hash) |
Converts an Integer to a Hash.
|
| IntegerToPixel(int, Avl.Pixel) |
Converts an integer value to pixel.
|
| InverseFourierTransform(Avl.Image, Avl.Image) |
Transforms an image in frequency domain back to spatial domain using inverse
Fourier transformation.
|
| InvertCoordinateSystem(Avl.CoordinateSystem2D, Avl.CoordinateSystem2D) |
Inverts a coordinate system.
|
| InvertImage(Avl.Image, Optional<Avl.Region>, float, Avl.Image) |
Applies numeric inversion (1/x) of the pixel values.
|
| IsCurrentWorkCancelled() | |
| JoinAdjacentPaths(List<Avl.Path>, float, float, Optional<float>, float, Optional<float>, Avl.PathJoiningMethod, Avl.PathJoiningAngleMeasure, bool, bool, float, List<Avl.Path>, Optional<List<Avl.Path>>) |
Joins those paths of an array which endpoints lie near enough.
|
| JoinImages_OfArray(List<Avl.Image>, Avl.JoinDirection, int, Avl.Image) |
Creates a single image by glueing together many input images in horizontal or
vertical direction.
|
| JoinImages_OfSeries(Avl.JoinImages_OfSeriesState, Avl.Image, Avl.JoinDirection, int, int, Conditional<Avl.Image>) |
Creates a single image by glueing together a series of input images in horizontal
or vertical direction.
|
| JoinImages(Avl.Image, Avl.Image, Optional<Avl.Image>, Optional<Avl.Image>, Avl.JoinDirection, int, Avl.Image) |
Creates a single image by glueing together the two input images in horizontal
or vertical direction.
|
| JoinImageTiles(List<Avl.Image>, int, int, Avl.Image) |
Joins previously cut tiles into single image.
|
| JoinPoint3DGrids(Avl.Point3DGrid, Avl.Point3DGrid, Optional<int>, Optional<int>, Avl.Point3DGrid) |
Combines two point grids into one.
|
| JoinProfilesIntoImage_OfSeries(Avl.JoinProfilesIntoImage_OfSeriesState, Avl.Profile, int, Conditional<Avl.Image>) |
Creates an image by joining 1D profiles, which appear in consecutive iterations.
|
| JoinProfilesIntoImage(List<Avl.Profile>, Avl.Image) |
Creates an image by joining an array of 1D profiles into consecutive image rows.
|
| JoinProfiles(Avl.Profile, Avl.Profile, Avl.Profile) |
Concatenates two profiles into one.
|
| JoinSurfaces(Avl.Surface, Avl.Surface, Avl.Surface) |
Combines two surfaces into one.
|
| KNN_Classify(Avl.KNNModel, List<float>, int, Avl.Metric, int) |
Classify data using the KNN classifier.
|
| KNN_Init(int, int, Avl.KNNModel) |
Initializes the KNN classifier.
|
| KNN_Train(Avl.KNNModel, List<List<float>>, List<int>, Avl.KNNModel) |
Trains KNN classifier using sample data.
|
| LabToRgb(Avl.Image, Avl.Image) |
Converts color space from L*a*b* to Red-Green-Blue.
|
| LawsFilter(Avl.Image, Optional<Avl.Region>, Avl.LawsFilterType, Avl.LawsFilterType, Avl.LawsFilterSize, int, bool, Avl.Image, Avl.Image) |
Filters image with one of the classic LAWS filter.
|
| LerpAngles(float, float, Optional<Avl.RotationDirection>, Avl.AngleRange, float, bool, float) |
Linearly interpolates between two angles in the direction of minimum turn.
|
| LerpImages_ByImage(Avl.Image, Avl.Image, Optional<Avl.Region>, Avl.Image, Avl.Image) |
Interpolates two images linearly pixel by pixel according to another image values.
|
| LerpImages(Avl.Image, Avl.Image, Optional<Avl.Region>, float, Avl.Image) |
Interpolates two images linearly pixel by pixel.
|
| LerpPaths(Avl.Path, Avl.Path, float, Avl.Path) |
Linearly interpolates between two paths.
|
| LerpPoints3D(Avl.Point3D, Avl.Point3D, float, Avl.Point3D) |
Linearly interpolates between two points in 3D.
|
| LerpPoints(Avl.Point2D, Avl.Point2D, float, Avl.Point2D) |
Linearly interpolates between two points.
|
| LerpSegments3D(Avl.Segment3D, Avl.Segment3D, float, Avl.Segment3D) |
Linearly interpolates between two segments in 3D.
|
| LerpSegments(Avl.Segment2D, Avl.Segment2D, float, bool, Avl.Segment2D) |
Linearly interpolates between two segments.
|
| LerpVectors3D(Avl.Vector3D, Avl.Vector3D, float, Avl.Vector3D) |
Linearly interpolates between two 3D vectors.
|
| LerpVectors_Radial(Avl.Vector2D, Avl.Vector2D, Optional<Avl.RotationDirection>, float, Avl.Vector2D) |
Linearly interpolates between two radial vectors.
|
| LerpVectors(Avl.Vector2D, Avl.Vector2D, float, Avl.Vector2D) |
Linearly interpolates between two vectors.
|
| lerp(Avl.Point2D, Avl.Point2D, float) | |
| Line2DToLine3D_AxesPlane(Avl.Line2D, Avl.PlaneType, float, Avl.Line3D, Optional<Avl.Plane3D>) |
Projects a 2D line onto a plane defined by 3D coordinate axes.
|
| Line2DToLine3D(Avl.Line2D, Avl.Line3D) |
Converts a line in 2D to a line in 3D.
|
| Line3DToLine2D_AxesPlane(Avl.Line3D, Avl.PlaneType, Avl.Line2D, Optional<Avl.Plane3D>) |
Projects a 3D line onto a plane defined by coordinate axes.
|
| Line3DToLine2D(Avl.Line3D, Avl.Line2D) |
Converts a line in 3D to a line in 2D by ignoring its Z coordinates.
|
| LinearBinaryPattern(Avl.Image, Optional<Avl.Region>, Avl.LinearBinaryPatternType, Avl.Histogram, Avl.Image) |
Creates histogram and map of Linear Binary Patterns (with radius 1 and size
8) of provided image.
|
| LineArcIntersection(Avl.Line2D, Avl.Arc2D, Conditional<Avl.Point2D>, Conditional<Avl.Point2D>) |
Computes the common points of an arc and a line.
|
| LinearRegression_LTE(List<float>, Optional<List<float>>, int, Optional<int>, Avl.LinearFunction, List<float>, List<float>, List<float>, List<float>, float, Diagnostic<int>) |
Computes linear regression of given point set using Least Trimmed Error algorithm.
|
| LinearRegression_M(List<float>, Optional<List<float>>, Avl.MEstimator, float, int, Optional<Avl.LinearFunction>, Avl.LinearFunction, List<float>, List<float>, Optional<List<float>>, Optional<List<float>>) |
Computes linear regression of given point set using selected M-estimator for
outlier suppression.
|
| LinearRegression_RANSAC(List<float>, Optional<List<float>>, Optional<int>, float, Optional<int>, Avl.LinearFunction, List<float>, List<float>) |
Computes linear regression of given point set using RANSAC.
|
| LinearRegression_TheilSen(List<float>, Optional<List<float>>, Avl.TheilSenVariant, Avl.LinearFunction, List<float>, List<float>) |
Computes linear regression of given point set using TheilSen algorithm.
|
| LinearRegression(List<float>, Optional<List<float>>, Avl.LinearFunction, List<float>, List<float>, float) |
Computes linear regression of given point set.
|
| LineCircleIntersection(Avl.Line2D, Avl.Circle2D, Conditional<Avl.Point2D>, Conditional<Avl.Point2D>) |
Computes common points of a circle and a line.
|
| LineLineIntersection3D(Avl.Line3D, Avl.Line3D, Conditional<Avl.Point3D>) |
Computes a common point of two lines in 3D.
|
| LineLineIntersection(Avl.Line2D, Avl.Line2D, Conditional<Avl.Point2D>) |
Computes a common point of two lines.
|
| LineNormalVector(Avl.Line2D, bool, Avl.Vector2D) |
Computes the normal vector of a line.
|
| LineOrientation(Avl.Line2D, float) |
Computes the orientation angle of a line as angle in the range from 0 to 180.
|
| LinePlaneIntersection3D(Avl.Line3D, Avl.Plane3D, Conditional<Avl.Point3D>) |
Computes the intersection point of a line in 3D and a plane.
|
| LineScanCameraModelToAnyCameraModel(Avl.LineScanCameraModel, Avl.AnyCameraModel) |
Conversion
|
| LineScanCameraModelToRectificationTransform(Avl.LineScanCameraModel, Avl.RectificationTransform) |
Conversion
|
| LineSegmentIntersection(Avl.Line2D, Avl.Segment2D, Conditional<Avl.Point2D>) |
Computes a common point of a line and a segment.
|
| LineThroughPoint3D(Avl.Point3D, Avl.Vector3D, Avl.Line3D) |
Computes a line in 3D passing through a point with given direction.
|
| LineThroughPoints3D(Avl.Point3D, Avl.Point3D, Avl.Line3D) |
Computes a line in 3D passing through two points.
|
| LineThroughPoints(Avl.Point2D, Avl.Point2D, Avl.Line2D) |
Computes a line passing through two distinct points.
|
| LineThroughPoint(Avl.Point2D, float, Avl.Line2D) |
Computes a line passing through a point with given angle.
|
| LineToLineDistance3D(Avl.Line3D, Avl.Line3D, float, float, Optional<Avl.Segment3D>) |
Measures the distance between two lines in 3D.
|
| LoadAnyCameraModel(string, Avl.AnyCameraModel) |
Loads serialized AnyCameraModel object from AVDATA file.
|
| LoadEdgeModel2(string, Avl.EdgeModel2) |
Loads serialized template matching EdgeModel2 object from AVDATA file.
|
| LoadEdgeModel(string, Avl.EdgeModel) |
Loads serialized template matching EdgeModel object from AVDATA file.
|
| LoadEntities_FromDxf(string, float, Optional<List<string>>, Avl.Point2D, List<List<Avl.Point2D>>, Diagnostic<List<string>>) |
Loads entities from a DXF file as an array of point arrays.
|
| LoadGrayModel2(string, Avl.GrayModel2) |
Loads serialized template matching GrayModel2 object from AVDATA file.
|
| LoadGrayModel(string, Avl.GrayModel) |
Loads serialized template matching GrayModel object from AVDATA file.
|
| LoadHistogram(string, Avl.Histogram) |
Loads serialized Histogram object from AVDATA file.
|
| LoadImageFormat(string, bool, Avl.ImageFormat) |
Loads a single image format from a file without loading all image data.
|
| LoadImageFromBuffer(Avl.ByteBuffer, int, Optional<int>, bool, Avl.Image) |
Loads a single image from a file stored in memory.
|
| LoadImageObject(string, Avl.Image) |
Loads serialized Image object from AVDATA file.
|
| LoadImage_FromDxf(string, float, Optional<Avl.Size>, Avl.Pixel, Optional<List<string>>, Avl.Point2D, Avl.Image, Diagnostic<List<string>>) |
Loads data from a DXF file as an image.
|
| LoadImage_FromWebsite(string, Optional<string>, Optional<string>, Avl.Image) |
Loads a JPG image from a website.
|
| LoadImage(string, bool, Avl.Image) |
Loads a single image from a file.
|
| LoadMultiplePagesTiffImage(string, bool, List<Avl.Image>) |
Loads a image array from a tiff file.
|
| LoadObject(string) | |
| LoadOcrMlpModel(string, Avl.OcrMlpModel) |
Loads serialized OcrMlpModel object from AVDATA file.
|
| LoadOcrModel(string, Avl.OcrModel) |
Loads serialized OcrMlpModel object from AVDATA file.
|
| LoadOcrSvmModel(string, Avl.OcrSvmModel) |
Loads serialized OcrSvmModel object from AVDATA file.
|
| LoadPath(string, Avl.Path) |
Loads serialized Path object from AVDATA file.
|
| LoadPoint3DArrayFromTextFile(string, Avl.Grid3DFileFormat, string, int, List<Avl.Point3D>, Diagnostic<string>, Diagnostic<Avl.Point3D>) |
Loads arrays of 3D points from text file.
|
| LoadPoint3DGridObject(string, Avl.Point3DGrid) |
Deserializes a profile from an AVDATA file.
|
| LoadPoint3DGridWithImage(string, Avl.Point3DFileFormat, Optional<int>, Optional<int>, Avl.Point3DGrid, Avl.Image) |
Loads entities from a file of one of available types as an array of points in
3D and an image. Assumes an ordered rectangular grid with no holes.
|
| LoadPoint3DGrid(string, Avl.Point3DFileFormat, bool, Avl.Point3DGrid) |
Loads entities from a file of one of available types as an array of points in
3D.
|
| LoadProfile(string, Avl.Profile) |
Deserializes a profile from an AVDATA file.
|
| LoadRectificationMap(string, Avl.RectificationMap) |
Loads serialized RectificationMap object from AVDATA file.
|
| LoadRectificationTransform(string, Avl.RectificationTransform) |
Loads serialized RectificationTransform object from AVDATA file.
|
| LoadRegion(string, Avl.Region) |
Loads a region from an AVDATA file.
|
| LoadSpatialMap(string, Avl.SpatialMap) |
Deserializes a SpatialMap object from a AVDATA file.
|
| LoadSurfaceWithImage(string, Avl.Point3DFileFormat, double, Avl.ValueLimits_f64, double, Avl.ValueLimits_f64, double, double, Avl.PlainType, Avl.SurfaceMultipointHeight, Avl.Pixel, Avl.Surface, Avl.Image, Optional<double>, Optional<double>, Diagnostic<Avl.Region>) |
Loads entities from a file of one of available types as an array of points in
3D and an image. Assumes an unordered grid with possible holes.
|
| LoadSurface(string, Avl.Surface) |
Deserializes a surface from an AVDATA file.
|
| LocateMultipleObjects_Edges1(Avl.Image, Optional<Avl.ShapeRegion>, Optional<Avl.CoordinateSystem2D>, Avl.EdgeModel, int, Optional<int>, float, Avl.EdgePolarityMode, Avl.EdgeNoiseLevel, bool, float, float, List<Avl.Object2D>, Optional<List<List<Avl.Path>>>, Optional<int>, Optional<Avl.ShapeRegion>, Diagnostic<List<Avl.Image>>, Diagnostic<List<Avl.Image>>, Diagnostic<List<List<float>>>) |
Finds all occurrences of a predefined template on an image by comparing object
edges.
|
| LocateMultipleObjects_Edges2(Avl.Image, Optional<Avl.ShapeRegion>, Optional<Avl.CoordinateSystem2D>, Avl.EdgeModel2, int, Optional<int>, float, Avl.EdgePolarityMode, Avl.EdgeNoiseLevel, bool, int, float, float, List<Avl.Object2D>, Optional<List<List<Avl.Path>>>, Optional<int>, Optional<Avl.ShapeRegion>, Diagnostic<List<Avl.Image>>, Diagnostic<List<Avl.Image>>, Diagnostic<List<List<float>>>) |
Finds all occurrences of a predefined template on an image by comparing object
edges.
|
| LocateMultipleObjects_Elastic(Avl.Image, Optional<Avl.ShapeRegion>, Optional<Avl.CoordinateSystem2D>, Avl.EdgeModel_Elastic, Avl.ElasticMatchingDetectionStrategy, float, float, float, float, List<Avl.Object2D>, List<List<Avl.Path>>, Optional<Avl.ShapeRegion>) |
Finds all occurrences of a predefined template on an image by comparing object
edges.
|
| LocateMultipleObjects_NCC2(Avl.Image, Optional<Avl.ShapeRegion>, Optional<Avl.CoordinateSystem2D>, Avl.GrayModel2, int, Optional<int>, bool, float, float, Optional<float>, Optional<float>, List<Avl.Object2D>, Optional<int>, Optional<Avl.ShapeRegion>, Diagnostic<List<Avl.Image>>, Diagnostic<List<Avl.Image>>, Diagnostic<List<List<float>>>) |
Finds all occurrences of a predefined template on an image by analysing the
normalized correlation between pixel values.
|
| LocateMultipleObjects_NCC(Avl.Image, Optional<Avl.ShapeRegion>, Optional<Avl.CoordinateSystem2D>, Avl.GrayModel, int, Optional<int>, bool, float, float, Optional<float>, Optional<float>, List<Avl.Object2D>, Optional<int>, Optional<Avl.ShapeRegion>, Diagnostic<List<Avl.Image>>, Diagnostic<List<Avl.Image>>, Diagnostic<List<List<float>>>) |
Finds all occurrences of a predefined template on an image by analysing the
normalized correlation between pixel values.
|
| LocateMultipleObjects_SAD(Avl.Image, Optional<Avl.ShapeRegion>, Optional<Avl.CoordinateSystem2D>, Avl.GrayModel, int, Optional<int>, bool, float, float, List<Avl.Object2D>, Optional<int>, Optional<Avl.ShapeRegion>, Diagnostic<List<Avl.Image>>, Diagnostic<List<Avl.Image>>, Diagnostic<List<List<float>>>) |
Finds multiple occurrences of a predefined template on an image by analysing
the Square Average Difference between pixel values.
|
| LocateMultiplePointPatterns(List<Avl.Point2D>, Optional<List<int>>, List<Avl.Point2D>, Optional<List<int>>, Optional<Avl.Rectangle2D>, bool, float, float, bool, float, float, float, float, float, float, float, bool, List<Avl.Rectangle2D>, List<List<Avl.Point2D>>, List<Avl.CoordinateSystem2D>, List<List<Avl.Segment2D>>) |
Finds occurrences of a pattern in a 2D cloud of (feature) points.
|
| LocateSingleObject_Edges1(Avl.Image, Optional<Avl.ShapeRegion>, Optional<Avl.CoordinateSystem2D>, Avl.EdgeModel, int, Optional<int>, float, Avl.EdgePolarityMode, Avl.EdgeNoiseLevel, bool, float, Conditional<Avl.Object2D>, Optional<Conditional<List<Avl.Path>>>, Optional<int>, Optional<Avl.ShapeRegion>, Diagnostic<List<Avl.Image>>, Diagnostic<List<Avl.Image>>, Diagnostic<Conditional<List<float>>>) |
Finds a single occurrence of a predefined template on an image by comparing
object edges.
|
| LocateSingleObject_Edges2(Avl.Image, Optional<Avl.ShapeRegion>, Optional<Avl.CoordinateSystem2D>, Avl.EdgeModel2, int, Optional<int>, float, Avl.EdgePolarityMode, Avl.EdgeNoiseLevel, bool, int, float, Conditional<Avl.Object2D>, Optional<Conditional<List<Avl.Path>>>, Optional<int>, Optional<Avl.ShapeRegion>, Diagnostic<List<Avl.Image>>, Diagnostic<List<Avl.Image>>, Diagnostic<Conditional<List<float>>>) |
Finds a single occurrence of a predefined template on an image by comparing
object edges.
|
| LocateSingleObject_Elastic(Avl.Image, Optional<Avl.ShapeRegion>, Optional<Avl.CoordinateSystem2D>, Avl.EdgeModel_Elastic, Avl.ElasticMatchingDetectionStrategy, float, float, float, float, Conditional<Avl.Object2D>, Optional<Conditional<List<Avl.Path>>>) |
Finds a single occurrence of a predefined template on an image by comparing
object edges.
|
| LocateSingleObject_NCC2(Avl.Image, Optional<Avl.ShapeRegion>, Optional<Avl.CoordinateSystem2D>, Avl.GrayModel2, int, Optional<int>, bool, float, Optional<float>, Optional<float>, Conditional<Avl.Object2D>, Optional<int>, Optional<Avl.ShapeRegion>, Diagnostic<List<Avl.Image>>, Diagnostic<List<Avl.Image>>, Diagnostic<Conditional<List<float>>>) |
Finds a single occurrence of a predefined template on an image by analysing
the normalized correlation between pixel values.
|
| LocateSingleObject_NCC(Avl.Image, Optional<Avl.ShapeRegion>, Optional<Avl.CoordinateSystem2D>, Avl.GrayModel, int, Optional<int>, bool, float, Optional<float>, Optional<float>, Conditional<Avl.Object2D>, Optional<int>, Optional<Avl.ShapeRegion>, Diagnostic<List<Avl.Image>>, Diagnostic<List<Avl.Image>>, Diagnostic<Conditional<List<float>>>) |
Finds a single occurrence of a predefined template on an image by analysing
the normalized correlation between pixel values.
|
| LocateSingleObject_SAD(Avl.Image, Optional<Avl.ShapeRegion>, Optional<Avl.CoordinateSystem2D>, Avl.GrayModel, int, Optional<int>, bool, float, Conditional<Avl.Object2D>, Optional<int>, Optional<Avl.ShapeRegion>, Diagnostic<List<Avl.Image>>, Diagnostic<List<Avl.Image>>, Diagnostic<Conditional<List<float>>>) |
Finds a single occurrence of a predefined template on an image by analysing
the Square Average Difference between pixel values.
|
| LocateSinglePointPattern(List<Avl.Point2D>, Optional<List<int>>, List<Avl.Point2D>, Optional<List<int>>, Optional<Avl.Rectangle2D>, bool, float, float, bool, float, float, float, float, float, float, Conditional<Avl.Rectangle2D>, Conditional<List<Avl.Point2D>>, Conditional<Avl.CoordinateSystem2D>, Conditional<List<Avl.Segment2D>>) |
Finds an occurrence of the pattern in the input points.
|
| LocationArrayToPoint2DArray(List<Avl.Location>, List<Avl.Point2D>) |
Converts an array of locations to an array of points.
|
| LocationCenter(Avl.Location, Avl.Point2D) |
Returns the center point of a pixel indicated by the provided location.
|
| LocationsToRegion(List<Avl.Location>, int, int, Avl.Region) |
Forms a region containing pixels of given locations.
|
| LocationToPoint2D(Avl.Location, Avl.Point2D) |
Converts a location to its center point.
|
| LogarithmImage(Avl.Image, Optional<Avl.Region>, Optional<float>, float, bool, Avl.Image, Diagnostic<Avl.Profile>) |
Computes a natural logarithm of each pixel.
|
| LUTTransformImage(Avl.LUTTransformImageState, Avl.Image, Optional<Avl.Region>, List<int>, List<Avl.Pixel>, bool, Avl.Image) |
Changes pixel values for data stored in array.
|
| MakeCharacterSamples(List<Avl.Region>, string, List<Avl.CharacterSample>) |
Creates training font samples from the provided regions.
|
| MakeHeatmap(Avl.Image, int, int, int, Avl.Heatmap) |
Creates a new Heatmap object.
|
| MakeHistogram(List<double>, float, float, int, Optional<int>, Avl.Histogram) |
Creates a histogram out of an array of bin values.
|
| MakeImage(List<Avl.Pixel>, int, int, Avl.PlainType, int, Avl.Image) |
Converts a pixel array to a single-channel image.
|
| MakePathConditional(Avl.Path, Avl.PathFeature, Optional<float>, Optional<float>, Conditional<Avl.Path>) |
Computes a path feature, checks whether its value is in range and creates a
conditional path on this basis.
|
| MakeRegionConditional(Avl.Region, Avl.RegionFeature, Optional<float>, Optional<float>, Conditional<Avl.Region>) |
Computes a region feature, checks whether its value is in range and creates
a conditional region on this basis.
|
| MakeSurfaceFromImage(Avl.Image, Optional<Avl.Region>, double, double, double, double, double, double, Avl.Surface) |
Creates a Surface structure from depth map mono image.
|
| MatrixDeterminant(Avl.Matrix, float) |
Find the determinant of a square matrix.
|
| MatrixPseudoEigenvectors(Avl.Matrix, Avl.Matrix, List<float>) |
Find the pseudo-eigenvalues and pseudo-eigenvectors of a symmetrical square
matrix.
|
| MatrixToImage(Avl.Matrix, Avl.Image) |
Converts a matrix to a single-channel real image.
|
| MatrixToRectificationTransform(Avl.Matrix, Avl.RectificationTransform) |
Conversion
|
| MaxChannels(Avl.Image, Optional<Avl.Region>, Avl.Image) |
Creates a monochromatic image by taking the maximum value of all the input image
channels.
|
| MaximumHistogram_OfArray(List<Avl.Histogram>, Avl.Histogram) |
Computes the maximum of histograms of an array bar by bar.
|
| MaximumHistogram_OfLoop(Avl.HistogramCombinators_OfLoopState, Avl.Histogram, Avl.Histogram) |
Computes the maximum of histograms appearing in consecutive iterations bar by
bar.
|
| MaximumHistogram(Avl.Histogram, Avl.Histogram, Avl.Histogram) |
Computes the maximum of two histograms bar by bar.
|
| MaximumImage_OfArray(List<Avl.Image>, Optional<Avl.Region>, Avl.Image) |
Computes the maximum of images of an array pixel by pixel.
|
| MaximumImage_OfLoop(Avl.ImageCombinators_OfLoopState, Avl.Image, Optional<Avl.Region>, Avl.Image) |
Computes the maximum of images appearing in consecutive iterations pixel by
pixel.
|
| MaximumImage(Avl.Image, Avl.Image, Optional<Avl.Region>, Avl.Image) |
Creates an image from the higher pixel values of each corresponding pair.
|
| MaximumProfile_OfArray(List<Avl.Profile>, Avl.Profile) |
Computes the maximum of profiles of an array.
|
| MaximumProfile_OfLoop(Avl.ProfileCombinators_OfLoopState, Avl.Profile, Avl.Profile) |
Computes the maximum of profiles appearing in consecutive iterations.
|
| MaximumProfile(Avl.Profile, Avl.Profile, Avl.Profile) |
Computes the maximum of two profiles point by point.
|
| MeasureClassificationQuality_Binary(List<bool>, List<bool>, float, float, float, float, Avl.Matrix) |
Calculates classification performance metrics for binary problems.
|
| MeasureClassificationQuality_Multiclass(List<int>, List<int>, float, List<float>, List<float>, List<float>, Avl.Matrix) |
Calculates classification performance metrics for multiclass problems.
|
| MeasureObjectWidth3D(Avl.Surface, List<Avl.ScanMap>, Avl.StripeScanParams3D, Avl.MeasureObjectMethod, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, Optional<Avl.MEstimator>, int, Conditional<float>, Conditional<Avl.Segment2D>, Conditional<Avl.Segment2D>, Optional<List<Conditional<Avl.SurfaceStripe1D>>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>) |
Measures the width of an object using stripe detection.
|
| MeasureObjectWidth(Avl.Image, List<Avl.ScanMap>, Avl.StripeScanParams, Avl.MeasureObjectMethod, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<Avl.MEstimator>, int, Conditional<float>, Conditional<Avl.Segment2D>, Conditional<Avl.Segment2D>, Optional<List<Conditional<Avl.Stripe1D>>>, Optional<List<Avl.Profile>>, Optional<List<Avl.Profile>>) |
Measures the width of an object using stripe detection.
|
| MeasurePixelVectors(Avl.Image, Optional<Avl.Region>, Avl.Image) |
Computes gradient magnitudes of an image.
|
| MedianAngle(List<float>, Avl.AngleRange, float) |
Computes the median angle of the input angles.
|
| MedianImages_OfArray(List<Avl.Image>, Optional<Avl.Region>, Avl.Image) |
Compute median value for each pixel of images from an array.
|
| MergeChannels(Avl.Image, Avl.Image, Optional<Avl.Image>, Optional<Avl.Image>, Avl.Image) |
Creates a multichannel image from several monochromatic ones.
|
| MergeCharactersIntoLines(List<Avl.OcrResult>, float, float, float, int, bool, string, Optional<List<List<Avl.OcrCandidate>>>, float, List<Avl.Rectangle2D>, List<string>, List<Conditional<int>>, List<float>, List<Avl.OcrResult>) |
Converts a output of Deep Learning filter DL_ReadCharacters to lines of text.
|
| MergeMultipleLocationResults(List<Avl.Object2D>, List<Avl.Object2D>, List<Avl.Object2D>, List<Avl.Object2D>, float, float, List<Avl.Object2D>, List<int>) |
Combines results from multiple LocateMultipleObject instances.
|
| MergeSingleLocationResults(Conditional<Avl.Object2D>, Conditional<Avl.Object2D>, Conditional<Avl.Object2D>, Conditional<Avl.Object2D>, float, Conditional<Avl.Object2D>, Conditional<int>) |
Combines results from multiple LocateSingleObject instances.
|
| MIL1DcodeFormatToBarcodeFormat(Avl.MIL1DcodeFormat, Avl.BarcodeFormat) |
Converts a MIL1DcodeFormat object to a BarcodeFormat.
|
| MinChannels(Avl.Image, Optional<Avl.Region>, Avl.Image) |
Creates a monochromatic image by taking the minimum value of all the input image
channels.
|
| MinimumHistogram_OfArray(List<Avl.Histogram>, Avl.Histogram) |
Computes the minimum of histograms of an array bar by bar.
|
| MinimumHistogram_OfLoop(Avl.HistogramCombinators_OfLoopState, Avl.Histogram, Avl.Histogram) |
Computes the minimum of histograms appearing in consecutive iterations bar by
bar.
|
| MinimumHistogram(Avl.Histogram, Avl.Histogram, Avl.Histogram) |
Computes the minimum of two histograms bar by bar.
|
| MinimumImage_OfArray(List<Avl.Image>, Optional<Avl.Region>, Avl.Image) |
Computes the minimum of images of an array pixel by pixel.
|
| MinimumImage_OfLoop(Avl.ImageCombinators_OfLoopState, Avl.Image, Optional<Avl.Region>, Avl.Image) |
Computes the minimum of images appearing in consecutive iterations pixel by
pixel.
|
| MinimumImage(Avl.Image, Avl.Image, Optional<Avl.Region>, Avl.Image) |
Creates an image from the lower pixel values of each corresponding pair.
|
| MinimumProfile_OfArray(List<Avl.Profile>, Avl.Profile) |
Computes the minimum of profiles of an array.
|
| MinimumProfile_OfLoop(Avl.ProfileCombinators_OfLoopState, Avl.Profile, Avl.Profile) |
Computes the minimum of profiles appearing in consecutive iterations.
|
| MinimumProfile(Avl.Profile, Avl.Profile, Avl.Profile) |
Computes the minimum of two profiles point by point.
|
| MirrorImage(Avl.Image, Avl.MirrorDirection, Avl.Image) |
Reverses the order of the input image columns or rows depending on inMirrorDirection
value.
|
| MirrorPoint3DArray(List<Avl.Point3D>, Avl.Plane3D, List<Avl.Point3D>, Optional<Avl.Matrix>) |
Mirrors each point from the array according to the input plane.
|
| MirrorPoint3DGrid(Avl.Point3DGrid, Avl.Plane3D, Avl.Point3DGrid, Optional<Avl.Matrix>) |
Mirrors each grid point according to the input plane.
|
| MirrorPoint3D(Avl.Point3D, Avl.Plane3D, Avl.Point3D, Optional<Avl.Matrix>) |
Mirrors a point according to the input plane.
|
| MirrorRegion(Avl.Region, Avl.MirrorDirection, Avl.Region) |
Mirrors a region across vertical or horizontal axis.
|
| MirrorSurface(Avl.Surface, Avl.Surface, Optional<Avl.Matrix>) |
Transforms Z coordinate of each surface point to its opposite value.
|
| MixChannels(Avl.Image, int, int, int, int, int, Avl.Image) |
Calculates a linear combination of image channels.
|
| MLP_Init(Optional<List<int>>, Avl.ActivationFunction, Avl.MlpPreprocessing, Optional<int>, int, int, Avl.MlpModel) |
Creates multilayer perceptron model.
|
| MLP_Respond(Avl.MlpModel, List<float>, List<float>) |
Calculates multilayer perceptron answer.
|
| MLP_Train(Avl.MlpModel, List<List<float>>, List<List<float>>, Optional<List<List<float>>>, Optional<List<List<float>>>, int, float, float, Optional<int>, Avl.MlpModel, Diagnostic<Avl.Profile>, Diagnostic<Avl.Profile>) |
Creates and trains multilayer perceptron classifier.
|
| MultiplyHistograms_OfArray(List<Avl.Histogram>, Avl.Histogram) |
Multiply histograms of an array bar by bar.
|
| MultiplyHistograms_OfLoop(Avl.HistogramCombinators_OfLoopState, Avl.Histogram, Avl.Histogram) |
Multiply histograms appearing in consecutive iterations bar by bar.
|
| MultiplyHistograms(Avl.Histogram, Avl.Histogram, Avl.Histogram) |
Multiplies two histograms bar by bar.
|
| MultiplyHistogram(Avl.Histogram, double, Avl.Histogram) |
Multiplies each bin value by a number.
|
| MultiplyImages_OfArray(List<Avl.Image>, Optional<Avl.Region>, float, Avl.Image) |
Multiplies images of an array pixel by pixel.
|
| MultiplyImages_OfLoop(Avl.ImageCombinators_OfLoopState, Avl.Image, Optional<Avl.Region>, float, Avl.Image) |
Multiplies images appearing in consecutive iterations pixel by pixel.
|
| MultiplyImages(Avl.Image, Avl.Image, Optional<Avl.Region>, float, Avl.Image) |
Multiplies two images pixel by pixel.
|
| MultiplyImage(Avl.Image, Optional<Avl.Region>, float, Avl.Image) |
Multiplies each pixel by a scalar value.
|
| MultiplyProfiles_OfArray(List<Avl.Profile>, Avl.Profile) |
Multiplies profiles of an array value by value.
|
| MultiplyProfiles_OfLoop(Avl.ProfileCombinators_OfLoopState, Avl.Profile, Avl.Profile) |
Multiplies profiles appearing in consecutive iterations value by value.
|
| MultiplyProfiles(Avl.Profile, Avl.Profile, Avl.Profile) |
Multiplies two profiles value by value.
|
| MultiplyProfile(Avl.Profile, Optional<Avl.Range>, float) |
Multiplies each element of a profile by a scalar value.
|
| NegateHistogram(Avl.Histogram, Avl.Histogram) |
Negates each bin value.
|
| NegateImage(Avl.Image, Optional<Avl.Region>, Avl.Image) |
Reverts the pixel value range (unsigned) or applies numeric negation (signed).
|
| NegateProfile(Avl.Profile, Optional<Avl.Range>) |
Transforms each profile value to its negation.
|
| NormalizeAngle(float) | |
| NormalizeAngle(float, Avl.AngleRange, float, float) |
Normalizes an angle to the range <x, x+90) or <x, x+180) or <x, x+360).
|
| NormalizeImage(Avl.Image, Optional<Avl.Region>, float, float, float, float, Optional<float>, Optional<float>, Avl.Image, float, float, Diagnostic<Avl.Region>) |
Rescales an image linearly, so that its minimum becomes inNewMinimum and the
maximum of the remaining pixels becomes inNewMaximum.
|
| NormalizeLocalBrightness_Gauss(Avl.Image, Optional<Avl.Region>, float, Optional<float>, float, float, Avl.Image) |
Normalizes local brightness of the image. Internally uses Gauss smoothing.
|
| NormalizeLocalBrightness_Mean(Avl.Image, Optional<Avl.Region>, int, Optional<int>, float, float, Avl.Image) |
Normalizes local brightness of the image. Internally uses Mean smoothing.
|
| NormalizeLocalContrast(Avl.Image, Optional<Avl.Region>, float, float, int, float, Avl.Image) |
Normalizes local contrast of the image using Wallis filter.
|
| NormalizeMatrixData(Avl.Matrix, Optional<Avl.Matrix>, Optional<Avl.Matrix>, Avl.Matrix, Avl.Matrix, Avl.Matrix) |
Treats Matrix as a data frame, where examples are in rows while columns represent
features, and normalizes the data by subtracting mean from each column and dividing
it by its standard deviation.
|
| NormalizePixelVectors(Avl.Image, Optional<Avl.Region>, Avl.GradientAngleRange, Avl.Image) |
Adjusts gradient angles to a given range.
|
| NormalizeProfile(Avl.Profile, Optional<Avl.Range>, Optional<float>, Optional<float>, float, float, Avl.Profile, float, float) |
Rescales a profile linearly, so that its minimum becomes inNewMinimum and its
maximum becomes inNewMaximum.
|
| NormalizeRectangleOrientation(Avl.Rectangle2D, float, Avl.RectangleOrientation, Avl.Rectangle2D) |
Changes orientation of the given rectangle according to parameters.
|
| NormalizeSegmentOrientation_ByBaseOrientation(Avl.Segment2D, float, Avl.Segment2D) |
Changes orientation of the given segment according to base orientation.
|
| NormalizeSegmentOrientation_ByCoordinate(Avl.Segment2D, Avl.Axis, Avl.Segment2D) |
Changes orientation of the given segment according to coordinates along selected
axis.
|
| NormalizeSegmentOrientation_ByPointDistance(Avl.Segment2D, Avl.Point2D, Avl.Segment2D) |
Changes orientation of the given segment according to distance to the given
point.
|
| NthImage_OfArray(List<Avl.Image>, Optional<List<Avl.Region>>, int, bool, Avl.Image) |
For each pixel location, get value of n-th (increasing) pixel among input images.
|
| OcrMlpModelToOcrModel(Avl.OcrMlpModel, Avl.OcrModel) |
Converts OcrMlpModel(old type) to OcrModel.
|
| OcrModelToOcrMlpModel(Avl.OcrModel, Avl.OcrMlpModel) |
Converts OcrModel to OcrMlpModel.
|
| OcrModelToOcrSvmModel(Avl.OcrModel, Avl.OcrSvmModel) |
Converts OcrModel to OcrSvmModel.
|
| OcrSvmModelToOcrModel(Avl.OcrSvmModel, Avl.OcrModel) |
Converts OcrSvmModel(old type) to OcrModel.
|
| OpenImage_AnyKernel(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, Optional<Avl.Pixel>, Avl.Region, Optional<Avl.Location>, Avl.Image) |
Removes small bright structures from an image (or fills in dark ones) by applying
consecutive erosion and dilation.
|
| OpenImage_Mask(Avl.Image, Optional<Avl.Region>, Optional<Avl.Pixel>, Avl.MorphologyKernel, Avl.Image) |
Removes small bright structures from an image (or fills in dark ones) by applying
consecutive erosion and dilation.
|
| OpenImage(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, Optional<Avl.Pixel>, Avl.KernelShape, int, Optional<int>, Avl.Image, Diagnostic<Avl.Region>) |
Removes small bright structures from an image (or fills in dark ones) by applying
consecutive erosion and dilation.
|
| OpenInputVideoStream(string, int, Avl.InputVideoStream, float, int) |
Opens and creates a video stream from a file.
|
| OpenOutputVideoStream(string, Avl.VideoEncoder, float, int, int, Avl.OutputVideoStream) |
Creates a video stream which will be saved to a selected file.
|
| OpenPath(Avl.Path) |
Removes the segment connecting the last point with the first one in a path.
|
| OpenRegion_AnyKernel(Avl.Region, Avl.Region, Avl.Region) |
Performs a morphological opening on a region using an arbitrary kernel.
|
| OpenRegion(Avl.Region, Avl.KernelShape, int, Optional<int>, Avl.Region) |
Performs a morphological opening on a region using a predefined kernel.
|
| OpenSurfacePoints(Avl.Surface, Optional<Avl.Region>, Avl.KernelShape, int, Optional<int>, bool, Avl.Surface) |
Removes some existing points from the input surface when some points in their
vicinity are missing.
|
| outerProduct(Avl.Vector3D, Avl.Vector3D) | |
| PassFailStatusToBool(bool, bool) |
Converts a pass/fail status to a bool value.
|
| PassFailStatusToHash(bool, Avl.Hash) |
Converts a PassFailStatus object to a Hash.
|
| PathAlongArc(Avl.Path, Avl.Arc2D, Avl.Axis, float, bool, Avl.Path) |
Transforms a path to a coordinate system in which the 'axis' arc is vertical
or horizontal.
|
| PathAlongPath(Avl.Path, Avl.Path, Avl.Axis, float, bool, Avl.Path) |
Transforms a path to a coordinate system in which the 'axis' path is vertical
or horizontal.
|
| PathArrayPoints(List<Avl.Path>, List<Avl.Point2D>) |
Converts an array of paths to an array of points.
|
| PathAverageTurnAngle(Avl.Path, float) |
Computes the average absolute turn angle of a path per unit of length.
|
| PathBoundingBox_OrNil(Avl.Path, Conditional<Avl.Box>) |
Computes the smallest box containing a path; returns NIL if the path is empty.
|
| PathBoundingBox(Avl.Path, Avl.Box) |
Computes the smallest box containing a path.
|
| PathBoundingCircle_OrNil(Avl.Path, Conditional<Avl.Circle2D>) |
Computes the smallest circle enclosing a path; returns NIL if the path is empty.
|
| PathBoundingCircle(Avl.Path, Avl.Circle2D) |
Computes the smallest circle enclosing a path.
|
| PathBoundingParallelogram(Avl.Path, Avl.BoundingRectangleFeature, Avl.Path, Optional<Avl.Point2D>, Optional<float>, Optional<float>, Optional<float>) |
Computes the smallest parallelogram containing a path.
|
| PathBoundingRectangle_FixedAngle_OrNil(Avl.Path, float, Conditional<Avl.Rectangle2D>, Conditional<Avl.Point2D>, Conditional<float>, Conditional<float>) |
Computes the smallest rectangle with the given orientation angle containing
a path; returns NIL when the path is empty.
|
| PathBoundingRectangle_FixedAngle(Avl.Path, float, Avl.Rectangle2D, Optional<Avl.Point2D>, Optional<float>, Optional<float>) |
Computes the smallest rectangle with the given orientation angle containing
a path.
|
| PathBoundingRectangle_OrNil(Avl.Path, Avl.BoundingRectangleFeature, float, Avl.RectangleOrientation, Conditional<Avl.Rectangle2D>, Conditional<Avl.Point2D>, Conditional<float>, Conditional<float>) |
Computes the smallest rectangle containing a path; returns NIL when the path
is empty.
|
| PathBoundingRectangle(Avl.Path, Avl.BoundingRectangleFeature, float, Avl.RectangleOrientation, Avl.Rectangle2D, Optional<Avl.Point2D>, Optional<float>, Optional<float>) |
Computes the smallest rectangle containing a path.
|
| PathCaliperDiameter(Avl.Path, Optional<Avl.Segment2D>, Optional<float>, Optional<Avl.Segment2D>, Optional<float>) |
Computes the longest and the shortest width of the input path measured as distance
between parallel lines containing the whole path.
|
| PathConvexHull(Avl.Path, Avl.Path) |
Computes the smallest convex shape that contains the given path.
|
| PathDiameter(Avl.Path, Optional<Avl.Segment2D>, Optional<float>) |
Finds the longest segment connecting two characteristic points of a path.
|
| PathEditDistance(Avl.Path, Avl.Path, int, int, int, Optional<Avl.CoordinateSystem2D>, Optional<List<Avl.Point2D>>, Optional<List<Avl.Point2D>>, Optional<List<Avl.Point2D>>, Optional<List<Avl.Point2D>>, Optional<List<Avl.Point2D>>, Optional<List<Avl.Point2D>>) |
Computes the edit distance between the input paths.
|
| PathEndpoints(Avl.Path, Avl.Point2D, Avl.Point2D) |
Returns the two endpoints of a path.
|
| PathLength(Avl.Path, float) |
Computes the total length of the input path.
|
| PathLineIntersections(Avl.Path, Avl.Line2D, List<Avl.Point2D>, Optional<List<int>>) |
Computes the common points of a path and a line.
|
| PathMassCenter_OrNil(Avl.Path, Conditional<Avl.Point2D>) |
Computes the average of the path points (all, not only characteristic ones);
returns NIL if the path is empty.
|
| PathMassCenter(Avl.Path, Avl.Point2D) |
Computes the average of the path points (all, not only characteristic ones).
|
| PathPathIntersections(Avl.Path, Avl.Path, List<Avl.Point2D>, Optional<List<int>>, Optional<List<int>>) |
Computes the common points of two paths.
|
| PathProjectionProfile(Avl.Path, Avl.Line2D, Avl.Profile, Diagnostic<List<Avl.Segment2D>>) |
Computes the distance from the line to the path.
|
| PathSegmentIntersections(Avl.Path, Avl.Segment2D, List<Avl.Point2D>, Optional<List<int>>) |
Computes the common points of a path and a segment.
|
| PathSegments(Avl.Path, List<Avl.Segment2D>) |
Converts a path to an array of line segments.
|
| PathSelfIntersections(Avl.Path, List<Avl.Point2D>, Optional<List<int>>, Optional<List<int>>, Optional<bool>) |
Checks if a path has any self-intersections and computes all of them.
|
| PathSize(Avl.Path, int) |
Returns the number of characteristic points on the input path.
|
| PathToLineDistanceProfile(Avl.Path, Avl.Line2D, float, Avl.Profile, Optional<List<float>>, Optional<List<Avl.Segment2D>>) |
Computes the profile of distances between a line and the characteristic points
of a path.
|
| PathToLineDistance(Avl.Path, Avl.Line2D, float, float, Optional<Avl.Segment2D>) |
Computes the smallest distance between a path and a line.
|
| PathToPathDistanceProfile(Avl.Path, Avl.Path, Avl.PathDistanceMode, float, Avl.Profile, Optional<List<float>>, Optional<List<Avl.Segment2D>>) |
Computes the profile of distances between two paths.
|
| PathToPathDistance(Avl.Path, Avl.Path, Avl.PathDistanceMode, float, float, Optional<Avl.Segment2D>) |
Computes the minimum distance between two paths.
|
| PathToPathMaximumDistance(Avl.Path, Avl.Path, Avl.PathDistanceMode, float, float, Optional<Avl.Segment2D>) |
Computes the distance between the farthest point of the input path from the
other path.
|
| PathToPoint2DArray(Avl.Path, List<Avl.Point2D>) |
Converts a path to an array of points.
|
| PathToPointDistanceProfile(Avl.Point2D, Avl.Path, float, Avl.Profile, Optional<List<float>>, Optional<List<Avl.Segment2D>>) |
Computes the profile of distances between the specified point and the characteristic
points of a path.
|
| PathToPointDistance(Avl.Point2D, Avl.Path, float, float, Optional<Avl.Segment2D>) |
Computes the smallest distance between a path and a point.
|
| PathToShapeRegion(Avl.Path, Avl.ShapeRegion) |
Converts a closed path to a shape region.
|
| PathTurnAngleLocalMaxima(Avl.Path, Avl.TurnAngleDirection, Avl.TurnAnglePrecision, float, float, float, List<float>, List<Avl.Point2D>, List<float>, Diagnostic<Avl.Path>, Diagnostic<Avl.Profile>) |
Finds the local maxima of the profile of turn angles of a path.
|
| PathTurnAngleMaximum_OrNil(Avl.Path, Avl.TurnAngleDirection, Avl.TurnAnglePrecision, Conditional<float>, Conditional<Avl.Point2D>, Conditional<float>) |
Finds the maximum of the profile of turn angles of a path; returns NIL if the
path has no turn angles.
|
| PathTurnAngleMaximum(Avl.Path, Avl.TurnAngleDirection, Avl.TurnAnglePrecision, float, Avl.Point2D, float) |
Finds the maximum of the profile of turn angles of a path.
|
| PathTurnAngleProfile(Avl.Path, Avl.Profile) |
Computes the profile of turn angles at characteristic points of a path.
|
| PhotometricStereo_ComputeHeightMap(Avl.Image, Avl.Image) |
Computes the shape of the image object using surface normals.
|
| PhotometricStereo_DestroyHeightMapStruct(Optional<int>, Optional<int>) |
Destroys a structure used for computing height map in photometric stereo filter.
|
| PhotometricStereo_General_Perform(List<Avl.Image>, List<float>, List<float>, Avl.Image, Avl.Image, Avl.Image) |
Computes surface normals using images with light source in different places.
|
| PhotometricStereo_InitializeHeightMapStruct(int, int) |
Creates a structure used for computing height map in photometric stereo filter.
|
| PhotometricStereo_Perform(Avl.Image, Avl.Image, Avl.Image, Avl.Image, float, float, Avl.Image, Avl.Image, Avl.Image) |
Computes surface normals using four images with light source in different places.
|
| PhotometricStereo_SurfaceCurvature(Avl.Image, Avl.CurvatureMeasure, float, Optional<float>, float, float, Avl.Image) |
Computes the surface curvature using previously computed normals.
|
| PinholeCameraModelToAnyCameraModel(Avl.PinholeCameraModel, Avl.AnyCameraModel) |
Conversion
|
| PinholeCameraModelToRectificationTransform(Avl.PinholeCameraModel, Avl.RectificationTransform) |
Conversion
|
| PixelToWebHMIColor(Avl.Pixel, string) |
Converts an image pixel to WebHMI color.
|
| PixelVectorDirAndPresence(Avl.Image, Optional<Avl.Region>, Avl.Image) |
Computes gradient orientations of an image.
|
| PlainTypeSize(Avl.PlainType) | |
| Plane3DNormalVector(Avl.Plane3D, Avl.Vector3D) |
Computes the normal vector of a line.
|
| Plane3DOrientation(Avl.Plane3D, float, float, float, Optional<Avl.Point3D>) |
Computes the orientation of a plane as angles in the range from 0 to 180 between
the plane and coordinate planes.
|
| PlanePlaneIntersection3D(Avl.Plane3D, Avl.Plane3D, Conditional<Avl.Line3D>) |
Computes a common line in 3D of two planes.
|
| PlaneThroughLineAndPoint3D(Avl.Line3D, Avl.Point3D, Avl.Plane3D) |
Computes a plane passing through a line and a point in 3D.
|
| PlaneThroughPoints3D(Avl.Point3D, Avl.Point3D, Avl.Point3D, Avl.Plane3D) |
Computes a plane passing through three distinct points in 3D.
|
| Point2DArrayToLocationArray(List<Avl.Point2D>, List<Avl.Location>) |
Converts an array of points to an array of locations.
|
| Point2DToLocation(Avl.Point2D, Avl.Location) |
Converts a point to a location its contained within.
|
| Point2DToPoint3D_AxesPlane(Avl.Point2D, Avl.PlaneType, float, Avl.Point3D, Optional<Avl.Plane3D>) |
Projects a 2D point onto a plane defined by 3D coordinate axes.
|
| Point2DToPoint3D(Avl.Point2D, Avl.Point3D) |
Converts a point in 2D to a point in 3D.
|
| Point3DArrayToPoint2DArray(List<Avl.Point3D>, List<Avl.Point2D>) |
Converts an array of points in 3D to an array of points in 2D by ignoring their
Z coordinates.
|
| Point3DGridDistance(Avl.Point3DGrid, Avl.Point3DGrid, Optional<Avl.Region>, float, List<Avl.Point3D>, List<Avl.Point3D>, float, float, List<float>) |
Computes distances between two input grids.
|
| Point3DGridHole(Avl.Point3DGrid, Optional<Avl.Region>, Avl.MEstimator, float, int, Optional<Avl.Plane3D>, Conditional<Avl.Region>, Conditional<Avl.Point3D>, Avl.Plane3D, Optional<List<Avl.Point3D>>, Optional<List<float>>, Optional<float>, Optional<float>, Optional<List<float>>, Optional<float>) |
Finds a biggest hole in a given section of point cloud.
|
| Point3DGridRMSE(Avl.Point3DGrid, Avl.Point3DGrid, double) |
Computes point-to-point RMSE between two point grids.
|
| Point3DGridToPoint3DArray(Avl.Point3DGrid, List<Avl.Point3D>) |
Converts a grid of points to an array of points removing nonexistent ones.
|
| Point3DGridValidPointsRegion(Avl.Point3DGrid, Optional<Avl.Region>, Avl.Region, Avl.Region) |
Computes region of locations where points are valid in a points 3D grid and
where they are invalid.
|
| Point3DToPoint2D_AxesPlane(Avl.Point3D, Avl.PlaneType, Avl.Point2D, Optional<Avl.Plane3D>) |
Projects a 3D point onto a plane defined by coordinate axes.
|
| Point3DToPoint2D(Avl.Point3D, Avl.Point2D) |
Converts a point in 3D to a point in 2D by ignoring its Z coordinate.
|
| PointAlongArc(Avl.Point2D, Avl.Arc2D, Avl.Axis, float, bool, Avl.Point2D) |
Transforms a point to a coordinate system in which the 'axis' arc is vertical
or horizontal.
|
| PointAlongPath(Avl.Point2D, Avl.Path, Avl.Axis, float, bool, Avl.Point2D) |
Transforms a point to a coordinate system in which the 'axis' path is vertical
or horizontal.
|
| Points2DToPoints3D_AxesPlane(List<Avl.Point2D>, Avl.PlaneType, float, List<Avl.Point3D>, Optional<Avl.Plane3D>) |
Projects an array of 2D points onto a plane defined by 3D coordinate axes.
|
| Points3DMedian(List<Avl.Point3D>, Optional<List<float>>, int, Avl.Point3D, Optional<float>, Diagnostic<List<Avl.Point3D>>) |
Computes the geometric median of the input points.
|
| Points3DToPoints2D_AxesPlane(List<Avl.Point3D>, Avl.PlaneType, List<Avl.Point2D>, Optional<Avl.Plane3D>) |
Projects an array of 3D points onto a plane defined by coordinate axes.
|
| PointsBoundingBox3D_OrNil(List<Avl.Point3D>, Conditional<Avl.Box3D>) |
Computes the smallest box in 3D containing an array of points in 3D; returns
NIL if the array is empty.
|
| PointsBoundingBox3D(List<Avl.Point3D>, Avl.Box3D) |
Computes the smallest box in 3D containing an array of points in 3D.
|
| PointsBoundingBox_OrNil(List<Avl.Point2D>, Conditional<Avl.Box>) |
Computes the smallest box containing an array of points; returns NIL if the
array is empty.
|
| PointsBoundingBox(List<Avl.Point2D>, Avl.Box) |
Computes the smallest box containing an array of points.
|
| PointsBoundingCircle_OrNil(List<Avl.Point2D>, Conditional<Avl.Circle2D>) |
Computes the smallest circle containing an array of points; returns NIL if the
array is empty.
|
| PointsBoundingCircle(List<Avl.Point2D>, Avl.Circle2D) |
Computes the smallest circle containing an array of points.
|
| PointsBoundingEllipse(List<Avl.Point2D>, Avl.Ellipse2D, List<Avl.Point2D>) |
Computes the smallest ellipse containing an array of points if such ellipse
exists.
|
| PointsBoundingParallelogram(List<Avl.Point2D>, Avl.BoundingRectangleFeature, Avl.Path, Optional<Avl.Point2D>, Optional<float>, Optional<float>, Optional<float>) |
Computes the smallest parallelogram containing an array of points.
|
| PointsBoundingRectangle_FixedAngle_OrNil(List<Avl.Point2D>, float, Conditional<Avl.Rectangle2D>, Conditional<Avl.Point2D>, Conditional<float>, Conditional<float>) |
Computes the smallest rectangle with the given orientation angle containing
an array of points; returns NIL when the array is empty.
|
| PointsBoundingRectangle_FixedAngle(List<Avl.Point2D>, float, Avl.Rectangle2D, Optional<Avl.Point2D>, Optional<float>, Optional<float>) |
Computes the smallest rectangle with the given orientation angle containing
an array of points.
|
| PointsBoundingRectangle_OrNil(List<Avl.Point2D>, Avl.BoundingRectangleFeature, float, Avl.RectangleOrientation, Conditional<Avl.Rectangle2D>, Conditional<Avl.Point2D>, Conditional<float>, Conditional<float>) |
Computes the smallest rectangle containing an array of points; returns NIL when
the array is empty.
|
| PointsBoundingRectangle(List<Avl.Point2D>, Avl.BoundingRectangleFeature, float, Avl.RectangleOrientation, Avl.Rectangle2D, Optional<Avl.Point2D>, Optional<float>, Optional<float>) |
Computes the smallest rectangle containing an array of points.
|
| PointsCaliperDiameter(List<Avl.Point2D>, Optional<Avl.Segment2D>, Optional<float>, Optional<Avl.Segment2D>, Optional<float>) |
Computes the longest and the shortest width of the input points measured as
distance between parallel lines containing all of them.
|
| PointsConvexHull(List<Avl.Point2D>, Avl.Path) |
Computes the smallest convex shape that contains the given array of points.
|
| PointsDiameter(List<Avl.Point2D>, Optional<Avl.Segment2D>, Optional<float>) |
Finds the longest segment connecting two points from a given array.
|
| PointSequenceDistances3D(List<Avl.Point3D>, bool, List<float>, Optional<float>, Optional<List<Avl.Segment3D>>) |
Measures the distances between consecutive points of a point sequence in 3D.
|
| PointSequenceDistances(List<Avl.Point2D>, bool, float, List<float>, Optional<float>, Optional<List<Avl.Segment2D>>) |
Measures the distances between consecutive points of a point sequence.
|
| PointsMassCenter3D(List<Avl.Point3D>, Avl.Point3D) |
Computes the central point of the input points.
|
| PointsMassCenter_OrNil(List<Avl.Point2D>, Conditional<Avl.Point2D>) |
Computes the central point of the input points; returns NIL if the array is
empty.
|
| PointsMassCenter(List<Avl.Point2D>, Avl.Point2D) |
Computes the central point of the input points.
|
| PointsMedian(List<Avl.Point2D>, Optional<List<float>>, int, Avl.Point2D, Optional<float>, Diagnostic<List<Avl.Point2D>>) |
Computes the geometric median of the input points.
|
| PointsOrientation(List<Avl.Point2D>, float) |
Computes the orientation of a set of 2D points.
|
| PointToArcDistance(Avl.Point2D, Avl.Arc2D, float, float, Optional<Avl.Segment2D>) |
Measures the distance between a point and an arc.
|
| PointToCircleDistance3D(Avl.Point3D, Avl.Circle3D, float, float, Optional<Avl.Segment3D>) |
Measures the distance between a 3D point and a circle in 3D.
|
| PointToCircleDistance(Avl.Point2D, Avl.Circle2D, float, float, Optional<Avl.Segment2D>) |
Measures the distance between a point and a circle.
|
| PointToLineDistance3D(Avl.Point3D, Avl.Line3D, float, float, Optional<Avl.Segment3D>) |
Measures the distance between a 3D point and a line in 3D.
|
| PointToLineDistance_Oriented(Avl.Point2D, Avl.Segment2D, float, float, Optional<Avl.Segment2D>) |
Measures the signed distance between a point and a line with direction.
|
| PointToLineDistance(Avl.Point2D, Avl.Line2D, float, float, Optional<Avl.Segment2D>, Optional<float>) |
Measures the distance between a point and a line.
|
| PointToPlaneDistance3D(Avl.Point3D, Avl.Plane3D, float, float, Optional<Avl.Segment3D>, Optional<float>) |
Measures the distance between a 3D point and a plane.
|
| PointToPointDistance3D(Avl.Point3D, Avl.Point3D, float, float, Optional<Avl.Segment3D>) |
Measures the distance between two 3D points.
|
| PointToPointDistance(Avl.Point2D, Avl.Point2D, float, float, Optional<Avl.Segment2D>) |
Measures the distance between two points.
|
| PointToRectangleDistance(Avl.Point2D, Avl.Rectangle2D, float, bool, float, Conditional<Avl.Segment2D>) |
Measures the distance between point and rectangle.
|
| PointToSegmentDistance3D(Avl.Point3D, Avl.Segment3D, float, float, Optional<Avl.Segment3D>) |
Measures the distance between a 3D point and a segment in 3D.
|
| PointToSegmentDistance(Avl.Point2D, Avl.Segment2D, float, float, Optional<Avl.Segment2D>) |
Measures the distance between a point and a segment.
|
| PolygonArea(Avl.Path, float) |
Computes the area of polygon.
|
| PolygonCircularity(Avl.Path, Avl.CircularityMeasure, float) |
Computes the area of a polygon divided by the area of a circle having the same
feature.
|
| PolygonConvexity(Avl.Path, float) |
Computes the area of a polygon divided by the area of its convex hull.
|
| PolygonEllipticAxes(Avl.Path, Avl.Segment2D, Avl.Segment2D) |
Computes axes of an ellipse having the same first and second order moments as
the given polygon.
|
| PolygonElongation(Avl.Path, float) |
Computes the elongation factor of a polygon (perfect circle has minimal elongation
equal 1.0).
|
| PolygonInscribedCircle(Avl.Path, Avl.Circle2D) |
Computes the circle with the maximal possible area contained in the input polygon.
|
| PolygonIntersectionArea_Convex(Avl.Path, Avl.Path, float) |
Computes the intersection area of two convex non-intersecting polygons.
|
| PolygonIntersection_Convex(Avl.Path, Avl.Path, Avl.Path) |
Finds the intersection of two convex non-intersecting polygons.
|
| PolygonMassCenter_OrNil(Avl.Path, Conditional<Avl.Point2D>) |
Computes the mass center of polygon; returns Nil for degenerate inputs.
|
| PolygonMassCenter(Avl.Path, Avl.Point2D) |
Computes the mass center of polygon.
|
| PolygonOrientation(Avl.Path, float) |
Computes the polygon orientation as angle with value in range 0.0 - 180.0.
|
| PolygonRectangularity(Avl.Path, float) |
Computes the area of a polygon divided by the area of its bounding rectangle.
|
| PolygonSecondOrderMoments(Avl.Path, float, float, float) |
Calculates all three second order moments in one pass.
|
| PolygonWithNormalizedOrientation(Avl.Path, Avl.Path) |
Returns the same polygon but with orientation corresponding to the axes.
|
| PowerImage(Avl.Image, Optional<Avl.Region>, float, Avl.Image) |
Exponentiates each pixel to the given power.
|
| ProfileAutocorrelation(Avl.Profile, int, int, int, int, bool, int, float, Avl.PeriodPrecisionMethod, List<float>, float, float) |
Computes the correlation between neighboring sub-profiles of different sizes
and infers the most probable period length.
|
| ProfileAverage(Avl.Profile, Optional<Avl.Range>, float) |
Computes the average value of a profile.
|
| ProfileCoordinates(Avl.Profile, Optional<Avl.Range>, List<float>, List<float>) |
Returns an array of all X and Y coordinates of the input profile.
|
| ProfileCorrelation(Avl.Profile, int, Avl.Profile, int, Optional<int>, float, Optional<float>, Diagnostic<Avl.Profile>, Diagnostic<Avl.Profile>) |
Computes the correlation between two sub-profiles.
|
| ProfileDistance(Avl.Profile, Avl.Profile, Optional<Avl.Range>, Avl.DistanceMeasure, float) |
Computes the [mean] square error between two profiles.
|
| ProfileEdges(Avl.Profile, Optional<Avl.Range>, bool, Avl.EdgeScanParams, float, Optional<float>, Optional<Avl.LocalBlindness>, List<Avl.ProfileEdge>, Optional<List<float>>, Optional<Avl.Profile>) |
Finds the locations at which the profile values raise or fall quickly.
|
| ProfileIndices(Avl.Profile, List<int>) |
Returns an array of all indices of the input profile (0, 1, 2, ...).
|
| ProfileLocalExtrema(Avl.Profile, Optional<Avl.Range>, bool, Avl.ExtremumType, Avl.ProfileInterpolationMethod, bool, Optional<float>, Optional<float>, Optional<Avl.LocalBlindness>, List<Avl.Extremum1D>) |
Finds the locations at which the values of the input profile are locally highest
or lowest.
|
| ProfileMaximum(Avl.Profile, Optional<Avl.Range>, Avl.ProfileInterpolationMethod, float, Optional<int>, Optional<float>) |
Finds the highest value of the input profile, its precise location and the corresponding
index.
|
| ProfileMinimum(Avl.Profile, Optional<Avl.Range>, Avl.ProfileInterpolationMethod, float, Optional<int>, Optional<float>) |
Finds the lowest value of the input profile, its precise location and the corresponding
index.
|
| ProfileRidges(Avl.Profile, Optional<Avl.Range>, bool, Avl.RidgeScanParams, float, Optional<float>, Optional<Avl.LocalBlindness>, List<Avl.ProfileRidge>, Optional<List<float>>, Optional<Avl.Profile>) |
Finds the high or low peaks in the input profile.
|
| ProfileSections(Avl.Profile, Optional<Avl.Range>, Optional<float>, Optional<float>, float, Optional<float>, float, Optional<float>, Optional<float>, List<Avl.ProfileSection>, Conditional<Avl.ProfileSection>) |
Finds subprofiles whose values fall into the specified range.
|
| ProfileSize(Avl.Profile, int) |
Returns the number of elements in a profile.
|
| ProfileStripes(Avl.Profile, Optional<Avl.Range>, bool, Avl.StripeScanParams, float, Optional<float>, Optional<Avl.LocalBlindness>, List<Avl.ProfileStripe>, Optional<List<float>>, Optional<Avl.Profile>) |
Finds pairs of opposite (raising and falling) edges in the input profile.
|
| ProfileSum(Avl.Profile, Optional<Avl.Range>, float) |
Computes the sum of profile values.
|
| ProfileToPoint2DArray(Avl.Profile, List<Avl.Point2D>) |
Converts a profile to an array of points.
|
| ProfileToRealArray(Avl.Profile, List<float>) |
Converts a profile to an array of real numbers.
|
| ProfileZeroCrossings(Avl.Profile, Optional<Avl.Range>, List<float>) |
Finds the points of a profile at which the profile intersects the x-axis.
|
| ProjectLineOntoPlane3D(Avl.Line3D, Avl.Plane3D, Avl.Line3D) |
Projects a line 3D onto a plane.
|
| ProjectPathOntoSurface(Avl.Surface, Avl.Path, Avl.Path) |
Returns a path consisting of interpolated single points of a surface given their
coordinates in surface coordinate system.
|
| ProjectPoint2DOntoPlane3D(Avl.Point2D, Avl.Plane3D, Avl.Point3D) |
Projects a point on a plane Z=0 onto a given plane, translating it parallel
to Z axis.
|
| ProjectPointOnCircle(Avl.Point2D, Avl.Circle2D, Avl.Point2D) |
Projects a point onto a circle.
|
| ProjectPointOnLine3D(Avl.Point3D, Avl.Line3D, Avl.Point3D) |
Projects a point 3D onto a line in 3D.
|
| ProjectPointOnLine(Avl.Point2D, Avl.Line2D, Avl.Point2D, float) |
Projects a point onto a line.
|
| ProjectPointOntoPlane3D(Avl.Point3D, Avl.Plane3D, Avl.Point3D) |
Projects a point 3D onto a plane.
|
| ProjectPointOntoSurface(Avl.Surface, Avl.Point2D, int, Optional<Avl.Point3D>, Optional<Avl.Point2D>) |
Returns an interpolated single point of a surface given its coordinates in surface
coordinate system.
|
| ProjectPointOrthogonal(Avl.Point3D, Avl.Point2D, Avl.Point2D) |
Converts a point through a simple orthogonal projection, parallel to the Z axis.
|
| ProjectPointPerspective(Avl.Point3D, Avl.Point2D, Avl.Point3D, float, Avl.Point2D) |
Converts a point through a perspective projection, parallel to the Z axis.
|
| ProjectPointsOnCircle(List<Avl.Point2D>, Avl.Circle2D, List<Avl.Point2D>, Conditional<Avl.Arc2D>) |
Projects points onto a circle.
|
| ProjectPointsOnLine3D(List<Avl.Point3D>, Avl.Line3D, List<Avl.Point3D>, Optional<Conditional<Avl.Segment3D>>) |
Projects points onto a line.
|
| ProjectPointsOnLine(List<Avl.Point2D>, Avl.Line2D, List<Avl.Point2D>, Optional<Conditional<Avl.Segment2D>>, float) |
Projects points onto a line.
|
| ProjectSurfaceOntoAxesPlane(Avl.Surface, Avl.PlaneType, Optional<double>, Avl.ValueLimits_f64, Optional<double>, Avl.ValueLimits_f64, double, Optional<double>, Avl.ValueLimits_f64, Avl.PlainType, Avl.SurfaceMultipointHeight, Avl.Surface, Optional<double>, Optional<double>, Diagnostic<Avl.Region>) |
Projects a surface onto one of three axes planes.
|
| ProjectSurfaceOntoPlane(Avl.Surface, Avl.Plane3D, bool, bool, Avl.Surface, Optional<Avl.Matrix>) |
Projects a surface on another plane, replacing Z coordinate of a point with
its distance from a given plane.
|
| project(Avl.Point2D, Avl.Line2D) | |
| PruneRegion(Avl.Region, int, Avl.Region) |
Removes one pixel wide branches from a region.
|
| QuadraticRegression_M(List<float>, Optional<List<float>>, Avl.MEstimator, float, int, Optional<Avl.QuadraticFunction>, Avl.QuadraticFunction, List<float>, List<float>, Optional<List<float>>, Optional<List<float>>) |
Computes quadratic regression of given point set using selected M-estimator
for outlier suppression.
|
| QuadraticRegression_RANSAC(List<float>, Optional<List<float>>, Optional<int>, float, Optional<int>, Avl.QuadraticFunction, List<float>, List<float>) |
Computes quadratic regression of given point set using RANSAC.
|
| QuadraticRegression(List<float>, Optional<List<float>>, Avl.QuadraticFunction, List<float>, List<float>, float) |
Computes quadratic regression of given point set.
|
| RandomPoint3D(Avl.RandomState, Avl.Box3D, Optional<int>, Avl.Point3D) |
Creates random 3D point inside given box.
|
| RandomPoint(Avl.RandomState, Avl.Box, Optional<int>, Avl.Point2D) |
Creates random point inside given box.
|
| ReadMultipleBarcodes(Avl.Image, Optional<Avl.ShapeRegion>, Optional<Avl.CoordinateSystem2D>, Avl.BarcodeParams, Avl.BarcodeDecodingParams, int, List<Avl.Barcode>, Optional<List<Avl.Rectangle2D>>, Optional<Avl.ShapeRegion>, Diagnostic<Avl.Image>, Diagnostic<List<List<Avl.Segment2D>>>) |
Reads multiple barcodes (1D) in the input image.
|
| ReadMultipleCodes_IK_Binary(Avl.Image, Optional<Avl.Rectangle2D>, Avl.CodeInverse1D, Optional<int>, Avl.CodeDetectionParameters, Avl.ManyCodeSettings, bool, Optional<Avl.Code128Parameters>, bool, Optional<Avl.DatamatrixParameters>, bool, bool, bool, bool, bool, bool, bool, bool, bool, Optional<Avl.GS1DatabarParameters>, Optional<Avl.CodabarParameters>, List<Avl.ByteBuffer>, List<Avl.Path>, List<Avl.CodeFormat>, List<float>) |
Reads multiple codes in the input image; returns binary data.
|
| ReadMultipleCodes_IK(Avl.Image, Optional<Avl.Rectangle2D>, Avl.CodeInverse1D, Optional<int>, Avl.CodeDetectionParameters, Avl.ManyCodeSettings, bool, Optional<Avl.Code128Parameters>, bool, Optional<Avl.DatamatrixParameters>, bool, bool, bool, bool, bool, bool, bool, bool, bool, Optional<Avl.GS1DatabarParameters>, Optional<Avl.CodabarParameters>, List<string>, List<Avl.Path>, List<Avl.CodeFormat>, List<float>) |
Reads multiple codes in the input image.
|
| ReadMultipleCodes_Z(Avl.ZCode_State, Avl.Image, Optional<string>, Optional<string>, Optional<int>, Optional<int>, Optional<int>, bool, Avl.Code1DSettings, bool, bool, List<Avl.ZResult>) |
Reads multiple 1D barcodes and PDF417 codes.
|
| ReadMultipleDataCodes(Avl.ReadDataCodes_State, Avl.Image, Optional<Avl.Rectangle2D>, Optional<Avl.CoordinateSystem2D>, Optional<Avl.MatrixSymbologies>, Optional<Avl.LinearSymbologies>, Avl.DataCodeDetectorParams, Avl.MatrixCodeParams, Avl.LinearCodeParams, bool, int, bool, List<Avl.DataCode>, List<Avl.Path>, Optional<Avl.Rectangle2D>) |
Reads multiple data codes (1D and 2D).
|
| ReadSingleBarcode(Avl.Image, Optional<Avl.ShapeRegion>, Optional<Avl.CoordinateSystem2D>, Avl.BarcodeParams, Avl.BarcodeDecodingParams, Conditional<Avl.Barcode>, Optional<List<Avl.Rectangle2D>>, Optional<Avl.ShapeRegion>, Diagnostic<Avl.Image>, Diagnostic<List<List<Avl.Segment2D>>>) |
Reads a single barcode (1D) in the input image.
|
| ReadSingleCode_IK_Binary(Avl.Image, Optional<Avl.Rectangle2D>, Avl.CodeInverse1D, Optional<int>, Avl.CodeDetectionParameters, bool, Optional<Avl.Code128Parameters>, bool, Optional<Avl.DatamatrixParameters>, bool, bool, bool, bool, bool, bool, bool, bool, bool, Optional<Avl.CodabarParameters>, Optional<Avl.GS1DatabarParameters>, Conditional<Avl.ByteBuffer>, Conditional<Avl.Path>, Conditional<Avl.CodeFormat>, Conditional<float>) |
Reads a single code in the input image; returns binary data.
|
| ReadSingleCode_IK(Avl.Image, Optional<Avl.Rectangle2D>, Avl.CodeInverse1D, Optional<int>, Avl.CodeDetectionParameters, bool, Optional<Avl.Code128Parameters>, bool, Optional<Avl.DatamatrixParameters>, bool, bool, bool, bool, bool, bool, bool, bool, bool, Optional<Avl.CodabarParameters>, Optional<Avl.GS1DatabarParameters>, Conditional<string>, Conditional<Avl.Path>, Conditional<Avl.CodeFormat>, Conditional<float>) |
Reads a single code in the input image.
|
| ReadSingleCode_Z(Avl.ZCode_State, Avl.Image, Optional<string>, Optional<string>, Optional<int>, Optional<int>, Avl.Code1DSettings, bool, bool, Conditional<Avl.ZResult>) |
Reads a single 1D barcode or a PDF417 code.
|
| ReadSingleDataCode(Avl.ReadDataCodes_State, Avl.Image, Optional<Avl.Rectangle2D>, Optional<Avl.CoordinateSystem2D>, Optional<Avl.MatrixSymbologies>, Optional<Avl.LinearSymbologies>, Avl.DataCodeDetectorParams, Avl.MatrixCodeParams, Avl.LinearCodeParams, bool, Conditional<Avl.DataCode>, List<Avl.Path>, Optional<Avl.Rectangle2D>) |
Reads a single data code (1D or 2D) in the input image.
|
| ReadText(List<Avl.Region>, Avl.OcrModel, float, string, List<Conditional<string>>, List<float>, bool) |
Ready-to-use tool for reading text from images using the OCR technique.
|
| ReadVideoStream(Avl.InputVideoStream, bool, int, Avl.Image) |
Acquires a frame from a previously opened video stream.
|
| RealArrayToPixelArray(List<float>, List<Avl.Pixel>) |
Converts an array of real values to an array of pixels.
|
| RealArrayToProfile(List<float>, Avl.Profile) |
Converts an array of real numbers to a profile.
|
| RealignImagePitch(Avl.Image, Avl.Image) |
Creates a new image with a standard pitch alignment.
|
| RealToPixel(float, Avl.Pixel) |
Converts a real value to pixel.
|
| RecognizeBarcode(Avl.Image, Avl.Rectangle2D, Optional<Avl.CoordinateSystem2D>, Avl.BarcodeParams, int, int, float, Conditional<Avl.Barcode>, Optional<Avl.Rectangle2D>, Diagnostic<List<Avl.Segment2D>>) |
Extracts information from a barcode located in the input image at a given position.
|
| RecognizeCharacters(List<Avl.Region>, Avl.OcrModel, Optional<Avl.Size>, bool, Avl.CharacterSortingOrder, Optional<float>, Optional<int>, string, List<float>, List<List<Avl.OcrCandidate>>, Diagnostic<List<Avl.Image>>, Diagnostic<List<Avl.Box>>) |
Classifies input regions into characters. Based on the Multi-Layer Perceptron
model.
|
| Rectangle2DToEllipse2D(Avl.Rectangle2D, Avl.Ellipse2D) |
Converts a rectangle to an ellipse .
|
| Rectangle2DToShapeRegionDeprecated(Avl.Rectangle2D, Avl.ShapeRegionDeprecated) | |
| Rectangle2DToShapeRegion(Avl.Rectangle2D, Avl.ShapeRegion) |
Converts a rectangle to region of interest.
|
| RectangleArea(Avl.Rectangle2D, float) |
Computes the area of a rectangle.
|
| RectangleBoundingBox(Avl.Rectangle2D, Avl.Box) |
Computes the smallest box containing a rectangle.
|
| RectangleBoundingCircle(Avl.Rectangle2D, Avl.Circle2D) |
Computes the smallest circle containing a rectangle.
|
| RectangleCenter(Avl.Rectangle2D, Avl.Point2D) |
Computes the center point of a rectangle.
|
| RectangleCharacteristicPoints(Avl.Rectangle2D, Optional<Avl.Point2D>, Optional<Avl.Point2D>, Optional<Avl.Point2D>, Optional<Avl.Point2D>, Optional<Avl.Point2D>, Optional<Avl.Point2D>, Optional<Avl.Point2D>, Optional<Avl.Point2D>, Optional<Avl.Point2D>, Optional<List<Avl.Point2D>>) |
Computes rectangle's characteristic points.
|
| RectangleCharacteristicPoint(Avl.Rectangle2D, Avl.Anchor2D, Avl.Point2D) |
Returns a characteristic point (e.g. the top-left) of the input rectangle.
|
| RectangleCorners(Avl.Rectangle2D, Avl.Point2D, Avl.Point2D, Avl.Point2D, Avl.Point2D) |
Computes the four corner points of a rectangle.
|
| RectanglePerimeterLength(Avl.Rectangle2D, float) |
Computes the perimeter length of a rectangle.
|
| RectangleSides(Avl.Rectangle2D, Optional<Avl.Segment2D>, Optional<Avl.Segment2D>, Optional<Avl.Segment2D>, Optional<Avl.Segment2D>) |
Returns segments representing the sides of the input rectangle.
|
| RectifyImage(Avl.Image, Avl.RectificationMap, Avl.Image, Optional<Avl.Matrix>, Optional<Avl.Point2D>, Optional<float>, Optional<float>) |
Applies a spatial map to distorted image transforming it to rectified image
defined in world coordinates.
|
| ReducePath(Avl.Path, float, Avl.Path, Diagnostic<List<Avl.Path>>) |
Reduces the number of points in a path preserving its shape with the specified
precision.
|
| ReduceSurface(Avl.Surface, Optional<Avl.Region>, Avl.Surface) |
Reduces surface dimensions as much as possible.
|
| ReflectRegion(Avl.Region, Avl.Location, Avl.Region) |
Reflects a region through the given location.
|
| RefreshOAuthToken(Avl.OAuthProvider, string, Conditional<Avl.OAuthUser>, Diagnostic<Conditional<string>>) |
Requests for refreshing current OAuth token.
|
| RegionArea(Avl.Region, int) |
Computes the number of pixels contained in a region.
|
| RegionBoundaries(Avl.Region, Avl.RegionConnectivity, Avl.Region) |
Removes interior pixels from a region.
|
| RegionBoundingBox_OrNil(Avl.Region, Conditional<Avl.Box>) |
Computes the smallest box containing a region; returns NIL if the region is
empty.
|
| RegionBoundingBox(Avl.Region, Avl.Box) |
Computes the smallest box containing a region.
|
| RegionBoundingCircle_OrNil(Avl.Region, Conditional<Avl.Circle2D>) |
Computes the smallest circle enclosing a region; returns NIL if the region is
empty.
|
| RegionBoundingCircle(Avl.Region, Avl.Circle2D) |
Computes the smallest circle enclosing a region.
|
| RegionBoundingEllipse_OrNil(Avl.Region, Conditional<Avl.Ellipse2D>) |
Computes the smallest ellipse enclosing a region; returns NIL if the region
is empty.
|
| RegionBoundingEllipse(Avl.Region, Avl.Ellipse2D) |
Computes the smallest ellipse enclosing a region.
|
| RegionBoundingParallelogram(Avl.Region, Avl.BoundingRectangleFeature, Avl.Path, Optional<Avl.Point2D>, Optional<float>, Optional<float>, Optional<float>) |
Computes the smallest parallelogram containing a region.
|
| RegionBoundingRectangle_FixedAngle_OrNil(Avl.Region, float, Conditional<Avl.Rectangle2D>, Conditional<Avl.Point2D>, Conditional<float>, Conditional<float>) |
Computes the smallest rectangle with the given orientation angle containing
a region; returns NIL if the region is empty.
|
| RegionBoundingRectangle_FixedAngle(Avl.Region, float, Avl.Rectangle2D, Optional<Avl.Point2D>, Optional<float>, Optional<float>) |
Computes the smallest rectangle with the given orientation angle containing
a region.
|
| RegionBoundingRectangle_OrNil(Avl.Region, Avl.BoundingRectangleFeature, float, Avl.RectangleOrientation, Conditional<Avl.Rectangle2D>, Conditional<Avl.Point2D>, Conditional<float>, Conditional<float>) |
Computes the smallest rectangle containing a region; returns NIL if the region
is empty.
|
| RegionBoundingRectangle(Avl.Region, Avl.BoundingRectangleFeature, float, Avl.RectangleOrientation, Avl.Rectangle2D, Optional<Avl.Point2D>, Optional<float>, Optional<float>) |
Computes the smallest rectangle containing a region.
|
| RegionCaliperDiameter(Avl.Region, Optional<Avl.Segment2D>, Optional<float>, Optional<Avl.Segment2D>, Optional<float>) |
Computes the longest and the shortest width of the input region measured as
distance between parallel lines containing the whole region.
|
| RegionCharacteristicPoint(Avl.Region, Avl.Anchor2D, Avl.Point2D) |
Returns a characteristic point of the input's region bounding box.
|
| RegionCircularity(Avl.Region, Avl.CircularityMeasure, float, Diagnostic<Avl.Circle2D>) |
Computes the area of a region divided by the area of a circular region having
the same feature.
|
| RegionComplement(Avl.Region, Avl.Region) |
Computes a region of pixels not contained in the input region.
|
| RegionComplexity(Avl.Region, float) |
Calculates how much the input region's perimeter is bigger than the perimeter
of a circle of the same area.
|
| RegionContours(Avl.Region, Avl.RegionContourMode, Avl.RegionConnectivity, List<Avl.Path>) |
Computes an array of closed paths corresponding to the contours of the input
region.
|
| RegionConvexHull_AsPath(Avl.Region, Avl.Path) |
Computes the smallest convex polygon containing the input region.
|
| RegionConvexHull(Avl.Region, Avl.Region) |
Computes the smallest convex region containing the input region.
|
| RegionConvexity(Avl.Region, float) |
Computes the area of a region divided by area of its convex hull.
|
| RegionDiameter(Avl.Region, Optional<Avl.Segment2D>, Optional<float>) |
Computes the longest segment connecting two pixels contained in region and its
length.
|
| RegionDifference(Avl.Region, Avl.Region, Avl.Region) |
Computes a region containing pixels from the first input region but not from
the second input region.
|
| RegionDirectionalDispersion(Avl.Region, float, Avl.ProjectionDirection, float) |
Directional standard deviation of the distance of the region's points to the
center.
|
| RegionDispersion(Avl.Region, float) |
Calculates how much more the input region's points are dispersed comparing to
the points of a circle of the same area.
|
| RegionEllipticAxes(Avl.Region, Avl.Segment2D, Avl.Segment2D) |
Computes axes of an ellipse having the same first and second order moments as
the given region.
|
| RegionElongation(Avl.Region, float) |
Computes the elongation factor of a region ( perfect circle has minimal elongation
equal 1.0 ).
|
| RegionFeatureValue(Avl.Region, Avl.RegionFeature, float) |
Computes the feature value of the input region.
|
| RegionHitAndMissTransform(Avl.Region, Avl.Region, Optional<Avl.Location>, Avl.Region, Optional<Avl.Location>, Avl.Region) |
Performs a hit-and-miss transformation on a region using arbitrary kernels.
|
| RegionHoles_Elastic(Avl.Region, Optional<Avl.Region>, int, List<Avl.Region>) |
Fills a ridges region with convex basins.
|
| RegionHoles(Avl.Region, Avl.RegionConnectivity, int, Optional<int>, List<Avl.Region>) |
Creates regions of the holes of the input region.
|
| RegionInscribedBox(Avl.Region, float, Optional<float>, int, Optional<int>, int, Optional<int>, Conditional<Avl.Box>) |
Computes the largest box contained in a region.
|
| RegionInscribedCircle(Avl.Region, Avl.Circle2D) |
Computes the largest circle contained in a region.
|
| RegionInteriors(Avl.Region, Avl.RegionConnectivity, Avl.Region) |
Removes boundary pixels from a region.
|
| RegionIntersection_OfArray(Optional<Avl.Region>, List<Avl.Region>, Avl.Region) |
Computes the common part of an array of regions.
|
| RegionIntersection_OfLoop(Avl.RegionCombinators_OfLoopState, Avl.Region, Avl.Region) |
Computes the common part of regions appearing in consecutive iterations.
|
| RegionIntersection(Avl.Region, Avl.Region, Avl.Region) |
Computes the common part of two regions.
|
| RegionMassCenter_OrNil(Avl.Region, Conditional<Avl.Point2D>, Optional<Conditional<int>>) |
Computes a point with coordinates equal to the average coordinates of the region's
pixels; returns NIL if the region is empty.
|
| RegionMassCenter(Avl.Region, Avl.Point2D, Optional<int>) |
Computes a point with coordinates equal to the average coordinates of the region's
pixels.
|
| RegionMedialAxis(Avl.Region, Avl.RegionSkeletonMethod, List<Avl.Path>) |
Computes an array of paths corresponding to the skeleton of the input region.
|
| RegionMoment(Avl.Region, Avl.RegionMomentType, bool, float, float) |
Computes selected second-order moment of a region in regular and normalized
( divided by region area ) variant.
|
| RegionNumberOfHoles(Avl.Region, Avl.RegionConnectivity, int, Optional<int>, int) |
Computes the number of holes in a region.
|
| RegionOrientation(Avl.Region, Avl.AngleRange, float) |
Computes the orientation of a region as an angle of value in a proper range.
|
| RegionOuterBoundaries(Avl.Region, List<Avl.Location>, List<Avl.Location>, List<Avl.Location>, List<Avl.Location>) |
Returns the top, right, bottom and left boundaries of the input region.
|
| RegionPerimeterLength(Avl.Region, float) |
Computes the length of the input region perimeter.
|
| RegionPointRunLengths(Avl.Region, List<int>) |
Returns the lengths of horizontal sequences of locations that constitute the
input region.
|
| RegionProjection(Avl.Region, Avl.ProjectionDirection, Avl.Profile) |
Computes the profile of the region pixel count in consecutive rows or columns.
|
| RegionRectangularity(Avl.Region, float) |
Computes the area of a region divided by the area of its bounding rectangle.
|
| RegionsFeatureValues(List<Avl.Region>, Avl.RegionFeature, List<float>) |
Computes the feature values of the input regions.
|
| RegionsIoU(Avl.Region, Avl.Region, double) |
Computes intersection over union value for two regions.
|
| RegionSkewness(Avl.Region, float, Avl.ProjectionDirection, float) |
Directional standard deviation of the distance of the region's points to the
center.
|
| RegionSymmetricDifference_OfArray(List<Avl.Region>, Avl.Region) |
Computes a region containing pixels belonging to an odd number of array regions.
|
| RegionSymmetricDifference_OfLoop(Avl.RegionCombinators_OfLoopState, Avl.Region, Avl.Region) |
Computes a region containing pixels belonging to an odd number of regions appearing
in consecutive iterations.
|
| RegionSymmetricDifference(Avl.Region, Avl.Region, Avl.Region) |
Computes a region containing pixels from first or second input region, but not
from both.
|
| RegionThickness(Avl.Region, float) |
Diameter of the biggest inscribed circle.
|
| RegionToImage(Avl.Region, Avl.Image) |
Converts a region to an image.
|
| RegionToLocations(Avl.Region, List<Avl.Location>) |
Converts a region to an array of its pixel locations.
|
| RegionToRegionDistance(Avl.Region, Avl.Region, float, float, Optional<Avl.Segment2D>) |
Computes minimal distance between one of the points of the first region with
one of the points of the second region.
|
| RegionToShapeRegion(Avl.Region, Avl.ShapeRegion) |
Converts a region to region of interest.
|
| RegionUnion_OfArray(List<Avl.Region>, Avl.Region) |
Computes a region containing all the pixels that any of the input regions contains.
|
| RegionUnion_OfLoop(Avl.RegionCombinators_OfLoopState, Avl.Region, Avl.Region) |
Computes the union of regions appearing in consecutive iterations.
|
| RegionUnion(Avl.Region, Avl.Region, Avl.Region) |
Computes a region containing pixels from both input regions.
|
| RemapImage(Avl.Image, Avl.SpatialMap, Optional<Avl.Region>, Avl.Image) |
Applies a precomputed image transform, defined by a spatial map object.
|
| RemoveBordersFromRegion(Avl.Region, int, int, Avl.Region) |
Removes from a region the pixels that lie very close to the region's frame.
|
| RemoveChannel(Avl.Image, int, Avl.Image) |
Creates an image by removing a single channel from the input image.
|
| RemoveEmptyBoxes(List<Avl.Box>, List<Avl.Box>, List<bool>) |
The input boxes which have both dimensions different from zero are copied to
the output.
|
| RemoveInvalidPoints3D(List<Avl.Point3D>, List<Avl.Point3D>) |
Removes invalid 3D points from an array (i.e. points with NaN or INF coordinates).
|
| RemoveInvalidPoints(List<Avl.Point2D>, List<Avl.Point2D>) |
Removes invalid points from an array (i.e. points with NaN or INF coordinates).
|
| RemoveOutliersFromPoint3DGrid(Avl.Point3DGrid, Optional<Avl.Region>, float, int, Avl.Point3DGrid, Diagnostic<float>, Diagnostic<float>) |
Removes noise from a given Point3DGrid. All points that are too far from their
neighbors are removed.
|
| RemovePathSelfIntersections(Avl.Path, Avl.Path) |
Removes all self-intersections from a given path.
|
| RemovePointFromPath(Avl.Path, int, bool) |
Removes a point from a path.
|
| RemoveRegionBlobs(Avl.Region, Avl.RegionConnectivity, Avl.RegionFeature, Optional<float>, Optional<float>, bool, Avl.Region) |
Splits a region into blobs, removes blobs not fulfilling the specified condition,
and merges the rest back into one region.
|
| RemoveRegionBoundaryBlobs(Avl.Region, Avl.Region, Avl.RegionConnectivity, Avl.Region) |
Removes all blobs intersecting a boundary of a given region.
|
| ReorientRectangle(Avl.Rectangle2D, int, Avl.Rectangle2D) |
Changes orientation of the given rectangle by multiple of 90 degrees.
|
| ReplaceInvalidSurfacePoints(Avl.Surface, Optional<Avl.Region>, float) |
Replaces all invalid points with a given Z value.
|
| ReplacePixels(Avl.Image, Optional<Avl.Region>, Avl.Pixel, Avl.Pixel, Avl.Image) |
Substitutes pixels having the specified value with a new value.
|
| ResamplePoint3DGrid(Avl.Point3DGrid, Avl.ValueLimits_f64, Avl.ValueLimits_f64, double, double, Avl.PlainType, Avl.SurfaceMultipointHeight, Avl.Surface, Optional<double>, Optional<double>, Diagnostic<Avl.Region>) |
Creates a surface structure from Point3DGrid taking into account X and Y coordinates
and trying to preserve continuity of the surface.
|
| ResampleSurface_AnyScales(Avl.Surface, Optional<double>, Optional<double>, Optional<double>, Optional<double>, Avl.Surface) |
Changes the coordinates format of the input surface.
|
| ResampleSurface(Avl.Surface, Avl.ResampleSurfaceMode, Optional<double>, Optional<double>, Avl.Surface) |
Equalizes the scales format of the input surface.
|
| ResaturateImage(Avl.Image, Optional<Avl.Region>, float, float, Avl.Image) |
Sets pixels below the low value to minimum, above the high value to maximum,
and interpolates the rest.
|
| RescaleArc(Avl.Arc2D, Optional<Avl.Point2D>, float, bool, Avl.Arc2D) |
Changes radius of an arc and translates its center in relation to a reference
point.
|
| RescaleBox3D(Avl.Box3D, Avl.Point3D, float, bool, Avl.Box3D) |
Changes the distances of box in 3D to a reference point.
|
| RescaleCircle3D(Avl.Circle3D, Optional<Avl.Point3D>, float, bool, Avl.Circle3D) |
Changes radius of a circle in 3D and translates its center in relation to a
reference point.
|
| RescaleCircle(Avl.Circle2D, Optional<Avl.Point2D>, float, bool, Avl.Circle2D) |
Changes radius of a circle and translates its center in relation to a reference
point.
|
| RescaleLine3D(Avl.Line3D, Avl.Point3D, float, bool, Avl.Line3D) |
Changes the input line in 3D distance to a reference point.
|
| RescaleLine(Avl.Line2D, Avl.Point2D, float, bool, Avl.Line2D) |
Changes the distance of a line to a reference point.
|
| RescalePathArray(List<Avl.Path>, Optional<Avl.Point2D>, float, bool, List<Avl.Path>) |
Translates each point of each path proportionally to its distance to a reference
point.
|
| RescalePath(Avl.Path, Optional<Avl.Point2D>, float, bool, Avl.Path) |
Translates each point of a path proportionally to its distance to a reference
point.
|
| RescalePixels_FixedRange(Avl.Image, Optional<Avl.Region>, float, float, float, float, Avl.Image) |
Transforms pixels value from given range into new one.
|
| RescalePixels(Avl.Image, Optional<Avl.Region>, float, float, Avl.Image) |
Applies linear transformation to pixel values.
|
| RescalePlane(Avl.Plane3D, Avl.Point3D, float, bool, Avl.Plane3D) |
Changes the input plane distance to a reference point.
|
| RescalePoint3DArray(List<Avl.Point3D>, Avl.Point3D, float, bool, List<Avl.Point3D>) |
Changes the distances of array points to a reference point.
|
| RescalePoint3DGrid(Avl.Point3DGrid, Avl.Point3D, float, bool, Avl.Point3DGrid) |
Changes the distances of grid points to a reference point.
|
| RescalePoint3D(Avl.Point3D, Avl.Point3D, float, bool, Avl.Point3D) |
Changes the distance of a point to a reference point.
|
| RescalePointArray(List<Avl.Point2D>, Optional<Avl.Point2D>, float, bool, List<Avl.Point2D>) |
Changes the distances of points from an array to a reference point.
|
| RescalePoint(Avl.Point2D, Avl.Point2D, float, bool, Avl.Point2D) |
Changes the distance of a point to a reference point.
|
| RescaleProfile(Avl.Profile, Optional<Avl.Range>, float, float) |
Applies a linear transformation to a profile.
|
| RescaleRectangle(Avl.Rectangle2D, Optional<Avl.Point2D>, float, bool, Avl.Rectangle2D) |
Changes the corners and the dimensions of a rectangle.
|
| RescaleSegment3D(Avl.Segment3D, Optional<Avl.Point3D>, float, bool, Avl.Segment3D) |
Lengthens or shortens a segment in 3D relatively.
|
| RescaleSegment(Avl.Segment2D, Optional<Avl.Point2D>, float, bool, Avl.Segment2D) |
Lengthens or shortens a segment relatively.
|
| RescaleSurface(Avl.Surface, Avl.Point3D, float, Optional<float>, Optional<float>, bool, Avl.Surface) |
Changes the distances of surface points to a reference point.
|
| RescaleVector3D(Avl.Vector3D, float, bool, Avl.Vector3D) |
Lengthens or shortens a 3D vector relatively preserving its direction.
|
| RescaleVector(Avl.Vector2D, float, bool, Avl.Vector2D) |
Lengthens or shortens a vector relatively preserving its direction.
|
| ResetIsCurrentWorkCancelled() | |
| ResizeArc_Delta(Avl.Arc2D, float, Avl.Arc2D) |
Changes radius of an arc by adding a value.
|
| ResizeArc(Avl.Arc2D, float, Avl.Arc2D) |
Changes radius of an arc.
|
| ResizeBox3D_Delta(Avl.Box3D, Avl.Anchor3D, float, float, float, Avl.Box3D) |
Changes the dimensions of a box in 3D by adding some values.
|
| ResizeBox3D_Relative(Avl.Box3D, Avl.Anchor3D, float, float, float, Avl.Box3D) |
Resizes a box in 3D to relatively defined dimensions.
|
| ResizeBox3D(Avl.Box3D, Avl.Anchor3D, Optional<float>, Optional<float>, Optional<float>, Avl.Box3D) |
Changes the dimensions of a box in 3D.
|
| ResizeBox_Delta(Avl.Box, Avl.Anchor2D, int, int, Avl.Box) |
Changes the dimensions of a box by adding some values.
|
| ResizeBox_Relative(Avl.Box, Avl.Anchor2D, float, float, Avl.Box) |
Resizes a box to relatively defined dimensions.
|
| ResizeBox(Avl.Box, Avl.Anchor2D, Optional<int>, Optional<int>, Avl.Box) |
Changes the dimensions of a box.
|
| ResizeCircle3D_Delta(Avl.Circle3D, float, Avl.Circle3D) |
Changes radius of a circle in 3D by adding a value.
|
| ResizeCircle3D(Avl.Circle3D, float, Avl.Circle3D) |
Changes radius of a circle in 3D.
|
| ResizeCircle_Delta(Avl.Circle2D, float, Avl.Circle2D) |
Changes radius of a circle by adding a value.
|
| ResizeCircle(Avl.Circle2D, float, Avl.Circle2D) |
Changes radius of a circle.
|
| ResizeImage_FixedAspectRatio(Avl.Image, Optional<int>, Avl.Dimension, Avl.ResizeMethod, Avl.Image) |
Changes one dimension of the image to a desired length while the other dimension
is set to a length such that the aspect ration of the image is maintained.
|
| ResizeImage_Relative(Avl.Image, float, float, Avl.ResizeMethod, Avl.Image) |
Resizes an image by a factor along each axis.
|
| ResizeImage(Avl.Image, Optional<Avl.Box>, Optional<int>, Optional<int>, Avl.ResizeMethod, Avl.Image) |
Enlarges or shrinks an image to new dimensions.
|
| ResizePixelVectors(Avl.Image, Optional<Avl.Region>, float, Avl.Image) |
Rescales an image treating pixels as vectors.
|
| ResizeProfile(Avl.Profile, int, Avl.ResizeProfileInterpolation, Avl.Profile) |
Changes the size of a profile, preserving its shape.
|
| ResizeRectangle_Delta(Avl.Rectangle2D, Avl.Anchor2D, float, float, Avl.Rectangle2D) |
Changes dimensions of a rectangle by adding some values.
|
| ResizeRectangle_Relative(Avl.Rectangle2D, Avl.Anchor2D, float, float, Avl.Rectangle2D) |
Changes dimensions of a rectangle relatively.
|
| ResizeRectangle(Avl.Rectangle2D, Avl.Anchor2D, Optional<float>, Optional<float>, Avl.Rectangle2D) |
Changes dimensions of a rectangle.
|
| ResizeRegion_Relative(Avl.Region, float, float, Avl.Region) |
Resizes region relatively along each axis.
|
| ResizeRegion(Avl.Region, Optional<int>, Optional<int>, Avl.Region) |
Enlarges or shrinks a region to new dimensions.
|
| ResizeSegment3D_Delta(Avl.Segment3D, float, float, Avl.Segment3D) |
Changes length of a segment in 3D by adding a value preserving its orientation
and center point.
|
| ResizeSegment3D(Avl.Segment3D, float, float, Avl.Segment3D) |
Lengthens or shortens a segment in 3D to a new length preserving its orientation
and center point.
|
| ResizeSegment_Delta(Avl.Segment2D, float, float, Avl.Segment2D) |
Changes length of a segment by adding a value preserving its orientation and
center point.
|
| ResizeSegment(Avl.Segment2D, float, float, Avl.Segment2D) |
Lengthens or shortens a segment to a new length preserving its orientation and
center point.
|
| ResizeVector3D_Delta(Avl.Vector3D, float, Avl.Vector3D) |
Extends length of a 3D vector by adding a value preserving its direction.
|
| ResizeVector3D(Avl.Vector3D, float, Avl.Vector3D) |
Lengthens or shortens a 3D vector preserving its direction.
|
| ResizeVector_Delta(Avl.Vector2D, float, Avl.Vector2D) |
Extends length of a vector by adding a value preserving its direction.
|
| ResizeVector(Avl.Vector2D, float, Avl.Vector2D) |
Lengthens or shortens a vector preserving its direction.
|
| ReverseArc(Avl.Arc2D, Avl.Arc2D) |
Inverts the direction of the arc.
|
| ReverseChannels(Avl.Image, Avl.Image) |
Reverses the order of channels in an image.
|
| ReversePath(Avl.Path) |
Reverses the order of points in a path.
|
| ReversePCATransform(Avl.Matrix, Avl.PCAModel, Avl.Matrix) |
Reverses Principal Component Analysis (PCA) process. Can be used to transform
data back to original feature space.
|
| ReverseSegment3D(Avl.Segment3D, Avl.Segment3D) |
Swaps the two endpoints of a segment in 3D.
|
| ReverseSegment(Avl.Segment2D, Avl.Segment2D) |
Swaps the two endpoints of a segment.
|
| reverse(Avl.Segment2D) | |
| RevokeOAuthAccess(Avl.OAuthProvider) |
Revokes the current OAuth access.
|
| Rgb555ToRgb888(Avl.Image, Avl.Image) |
Converts a RGB555 image into a RGB888 one.
|
| Rgb565ToRgb888(Avl.Image, Avl.Image) |
Converts a RGB565 image into a RGB888 one.
|
| Rgb888ToRgb555(Avl.Image, Avl.Image) |
Converts a RGB888 image into a RGB555 one.
|
| Rgb888ToRgb565(Avl.Image, Avl.Image) |
Converts a RGB888 image into a RGB565 one.
|
| RgbToCmyk(Avl.Image, Avl.Image) |
Converts color space from Red-Green-Blue into Cyan-Magenta-Yellow-Key.
|
| RgbToHsi(Avl.Image, Avl.Image) |
Converts color space from Red-Green-Blue into Hue-Saturation-Intensity.
|
| RgbToHsl(Avl.Image, Avl.Image) |
Converts color space from Red-Green-Blue to Hue-Saturation-Luminance.
|
| RgbToHsv(Avl.Image, Avl.Image) |
Converts color space from Red-Green-Blue to Hue-Saturation-Value.
|
| RgbToLab(Avl.Image, Avl.Image) |
Converts color space from Red-Green-Blue to L*a*b*.
|
| RgbToXyz(Avl.Image, Avl.Image) |
Converts color space from Red-Green-Blue to XYZ.
|
| RgbToYCoCgR(Avl.Image, Avl.Image) |
Converts color space from Red-Green-Blue into pseudointensitY-Orange-Green-with-Reversibility.
|
| RgbToYCoCg(Avl.Image, Avl.Image) |
Converts color space from Red-Green-Blue into pseudointensitY-Orange-Green.
|
| RgbToYuv(Avl.Image, Avl.Image) |
Converts color space from Red-Green-Blue into YUV.
|
| Ring2DToShapeRegion(Avl.Ring2D, Avl.ShapeRegion) |
Converts a ring to region of interest.
|
| RollingAverageImages_OfArray(List<Avl.Image>, Optional<Avl.Region>, float, Avl.Image) |
Averages images appearing in an array pixel by pixel using exponential rolling
average.
|
| RollingAverageImages_OfLoop(Avl.ImageCombinators_OfLoopState, Avl.Image, Optional<Avl.Region>, float, Avl.Image) |
Averages images appearing in consecutive iterations pixel by pixel using exponential
rolling average.
|
| RotateAngle_Toward(float, float, Avl.AngleRange, float, bool, float) |
Changes the input direction in the direction of minimum rotation toward the
target direction.
|
| RotateAngle(float, float, Avl.AngleRange, bool, float) |
Adds two angles.
|
| RotateArc(Avl.Arc2D, Optional<Avl.Point2D>, float, bool, Avl.Arc2D) |
Rotates an arc clockwise around center point.
|
| RotateCircle3D_AroundSegment(Avl.Circle3D, Avl.Segment3D, float, bool, Avl.Circle3D) |
Rotates a circle in 3D around a segment (the axis) in 3D.
|
| RotateCircle3D(Avl.Circle3D, Avl.Line3D, float, bool, Avl.Circle3D) |
Rotates a circle in 3D around an axis in 3D.
|
| RotateCircle(Avl.Circle2D, Avl.Point2D, float, bool, Avl.Circle2D) |
Rotates a circle clockwise around a center point.
|
| RotateCoordinateSystem(Avl.CoordinateSystem2D, Optional<Avl.Point2D>, float, bool, Avl.CoordinateSystem2D) |
Rotates a coordinate system around a center point.
|
| RotateImage(Avl.Image, float, Avl.RotationSizeMode, Avl.InterpolationMethod, bool, Avl.Image, Optional<Avl.CoordinateSystem2D>) |
Rotates an image clockwise.
|
| RotateLine3D_AroundSegment(Avl.Line3D, Avl.Segment3D, float, bool, Avl.Line3D) |
Rotates a line in 3D around a segment (the axis) in 3D.
|
| RotateLine3D(Avl.Line3D, Avl.Line3D, float, bool, Avl.Line3D) |
Rotates a line in 3D around an axis in 3D.
|
| RotateLine(Avl.Line2D, Avl.Point2D, float, bool, Avl.Line2D) |
Rotates a line clockwise around a center point.
|
| RotatePathArray(List<Avl.Path>, Optional<Avl.Point2D>, float, bool, List<Avl.Path>) |
Rotates an array of paths clockwise around a center point.
|
| RotatePath(Avl.Path, Optional<Avl.Point2D>, float, bool, Avl.Path) |
Rotates a path clockwise around a center point.
|
| RotatePixelVectors(Avl.Image, Optional<Avl.Region>, float, Avl.Image) |
Rotates image gradients.
|
| RotatePlane_AroundSegment(Avl.Plane3D, Avl.Segment3D, float, bool, Avl.Plane3D) |
Rotates a plane in 3D around a segment (the axis) in 3D.
|
| RotatePlane(Avl.Plane3D, Avl.Line3D, float, bool, Avl.Plane3D) |
Rotates a plane in 3D around an axis in 3D.
|
| RotatePoint3DArray_AroundSegment(List<Avl.Point3D>, Avl.Segment3D, float, bool, List<Avl.Point3D>, Optional<Avl.Matrix>) |
Rotates an array of 3D points around a segment (the axis).
|
| RotatePoint3DArray(List<Avl.Point3D>, Avl.Line3D, float, bool, List<Avl.Point3D>, Optional<Avl.Matrix>) |
Rotates an array of 3D points around an axis in 3D.
|
| RotatePoint3DGrid_AroundSegment(Avl.Point3DGrid, Avl.Segment3D, float, bool, Avl.Point3DGrid, Optional<Avl.Matrix>) |
Rotates a grid of 3D points around an segment3D (the axis) in 3D.
|
| RotatePoint3DGrid(Avl.Point3DGrid, Avl.Line3D, float, bool, Avl.Point3DGrid, Optional<Avl.Matrix>) |
Rotates a grid of 3D points around an axis in 3D.
|
| RotatePoint3D_AroundSegment(Avl.Point3D, Avl.Segment3D, float, bool, Avl.Point3D, Optional<Avl.Matrix>) |
Rotates a 3D point around a segment (the axis).
|
| RotatePoint3D(Avl.Point3D, Avl.Line3D, float, bool, Avl.Point3D, Optional<Avl.Matrix>) |
Rotates a 3D point around an axis in 3D.
|
| RotatePointArray(List<Avl.Point2D>, Optional<Avl.Point2D>, float, bool, List<Avl.Point2D>) |
Rotates an array of points clockwise around a center point.
|
| RotatePoint(Avl.Point2D, Avl.Point2D, float, bool, Avl.Point2D) |
Rotates a point clockwise around a center point.
|
| RotateProfile(Avl.Profile, int, Avl.Profile) |
Moves the last element ahead of the first one (inShift times).
|
| RotateRectangle(Avl.Rectangle2D, Optional<Avl.Point2D>, float, bool, Avl.Rectangle2D) |
Rotates a rectangle clockwise around a center point.
|
| RotateRegion(Avl.Region, Optional<Avl.Point2D>, float, bool, Avl.RotationSizeMode, Optional<int>, Optional<int>, Avl.Region, Optional<Avl.CoordinateSystem2D>) |
Rotates a region around a specified point.
|
| RotateSegment3D_AroundSegment(Avl.Segment3D, Avl.Segment3D, float, bool, Avl.Segment3D) |
Rotates a segment in 3D around a segment (the axis) in 3D.
|
| RotateSegment3D(Avl.Segment3D, Avl.Line3D, float, bool, Avl.Segment3D) |
Rotates a segment in 3D around an axis in 3D.
|
| RotateSegment(Avl.Segment2D, Optional<Avl.Point2D>, float, bool, Avl.Segment2D) |
Rotates a segment clockwise around a center point.
|
| RotateVector3D(Avl.Vector3D, Avl.Vector3D, float, bool, Avl.Vector3D) |
Rotates a 3D vector around another 3D vector (the axis).
|
| RotateVector(Avl.Vector2D, float, bool, Avl.Vector2D) |
Rotates a vector clockwise.
|
| SaveAnyCameraModel(Avl.AnyCameraModel, string) |
Saves serialized AnyCameraModel object as AVDATA file.
|
| SaveEdgeModel2(Avl.EdgeModel2, string) |
Saves serialized template matching EdgeModel2 object as AVDATA file.
|
| SaveEdgeModel(Avl.EdgeModel, string) |
Saves serialized template matching EdgeModel object as AVDATA file.
|
| SaveGrayModel2(Avl.GrayModel2, string) |
Saves serialized template matching GrayModel2 object as AVDATA file.
|
| SaveGrayModel(Avl.GrayModel, string) |
Saves serialized template matching GrayModel object as AVDATA file.
|
| SaveHistogram(Avl.Histogram, string) |
Saves serialized Histogram object as AVDATA file.
|
| SaveImageObject(Avl.Image, string) |
Saves serialized Image object as AVDATA file.
|
| SaveImageToBuffer(Avl.Image, Avl.ImageFileFormat, Avl.ByteBuffer) |
Saves an image to a file stored in ByteBuffer.
|
| SaveImageToJpeg_Asynchronous(Avl.SaveImageState, int, Avl.Image, string, Optional<int>, bool) |
Saves an image to a JPEG file in the background thread.
|
| SaveImageToJpeg(Avl.Image, string, Optional<int>, bool) |
Saves an image to a JPEG file.
|
| SaveImageToPng_Asynchronous(Avl.SaveImageState, int, Avl.Image, string, Optional<int>, bool) |
Saves an image to a PNG file in the background thread.
|
| SaveImageToPng(Avl.Image, string, Optional<int>, bool) |
Saves an image to a PNG file.
|
| SaveImageToTiff_Asynchronous(Avl.SaveImageState, int, Avl.Image, string, Optional<Avl.TiffImageCompressionScheme>, Optional<int>, bool) |
Saves an image to a TIFF file in the background thread.
|
| SaveImageToTiff(Avl.Image, string, Optional<Avl.TiffImageCompressionScheme>, Optional<int>, bool) |
Saves an image to a TIFF file.
|
| SaveImage_Asynchronous(Avl.SaveImageState, int, Avl.Image, Optional<Avl.ImageFileFormat>, string, bool) |
Saves an image to a file in the background thread.
|
| SaveImage(Avl.Image, Optional<Avl.ImageFileFormat>, string, bool) |
Saves an image to a file.
|
| SaveObject(T, string, int) | |
| SaveOcrMlpModel(Avl.OcrMlpModel, string) |
Saves serialized OcrMlpModel object as AVDATA file.
|
| SaveOcrModel(Avl.OcrModel, string) |
Saves serialized OcrMlpModel object as AVDATA file.
|
| SaveOcrSvmModel(Avl.OcrSvmModel, string) |
Saves serialized OcrSvmModel object as AVDATA file.
|
| SavePath(Avl.Path, string) |
Saves serialized Path object as AVDATA file.
|
| SavePoint3DGridObject(Avl.Point3DGrid, string) |
Serializes a profile to an AVDATA file.
|
| SavePoint3DGrid(string, Avl.Point3DGrid, Avl.Point3DFileFormat, Avl.StreamMode) |
Saves Point3DGrid in to file in one of the supported formats.
|
| SaveProfile(Avl.Profile, string) |
Serializes a profile to an AVDATA file.
|
| SaveRectificationMap(Avl.RectificationMap, string) |
Saves serialized RectificationMap object as AVDATA file.
|
| SaveRectificationTransform(Avl.RectificationTransform, string) |
Saves serialized RectificationTransform object as AVDATA file.
|
| SaveRegion(Avl.Region, string) |
Saves a serialized region object to an AVDATA file.
|
| SaveSpatialMap(Avl.SpatialMap, string) |
Serializes a SpatialMap object to an AVDATA file.
|
| SaveSurface(Avl.Surface, string) |
Serializes a surface to an AVDATA file.
|
| ScanExactlyNEdges3D_Direct(Avl.Surface, Avl.Path, Optional<Avl.CoordinateSystem2D>, Optional<float>, int, Avl.InterpolationMethod, Avl.EdgeScanParams3D, int, Avl.Selection, float, Optional<float>, Optional<Avl.LocalBlindness>, Optional<int>, Conditional<List<Avl.SurfaceEdge1D>>, Optional<Avl.Path>, Optional<Avl.Profile>, Optional<Avl.Profile>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Locates a specified number of the strongest changes of surface height along
a given path.
|
| ScanExactlyNEdges3D(Avl.Surface, Avl.ScanMap, Avl.EdgeScanParams3D, int, Avl.Selection, float, Optional<float>, Optional<Avl.LocalBlindness>, Optional<int>, Conditional<List<Avl.SurfaceEdge1D>>, Optional<Avl.Profile>, Optional<Avl.Profile>) |
Locates a specified number of the strongest changes of surface height along
a given path.
|
| ScanExactlyNEdges_Direct(Avl.Image, Avl.Path, Optional<Avl.CoordinateSystem2D>, int, Avl.SamplingParams, Avl.EdgeScanParams, int, Avl.Selection, float, Optional<float>, Optional<Avl.LocalBlindness>, Conditional<List<Avl.Edge1D>>, Conditional<List<Avl.Gap1D>>, Optional<Avl.Path>, Optional<Avl.Profile>, Optional<Avl.Profile>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Locates a specified number of the strongest transitions between dark and bright
pixels along a given path (without a scan map).
|
| ScanExactlyNEdges(Avl.Image, Avl.ScanMap, Avl.EdgeScanParams, int, Avl.Selection, float, Optional<float>, Optional<Avl.LocalBlindness>, Conditional<List<Avl.Edge1D>>, Conditional<List<Avl.Gap1D>>, Optional<Avl.Profile>, Optional<Avl.Profile>) |
Locates a specified number of the strongest transitions between dark and bright
pixels along a given path.
|
| ScanExactlyNRidges3D_Direct(Avl.Surface, Avl.Path, Optional<Avl.CoordinateSystem2D>, Optional<float>, int, Avl.InterpolationMethod, Avl.RidgeScanParams3D, int, Avl.Selection, float, Optional<float>, Optional<Avl.LocalBlindness>, Optional<int>, Conditional<List<Avl.SurfaceRidge1D>>, Optional<Avl.Path>, Optional<Avl.Profile>, Optional<Avl.Profile>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Locates a specified number of the strongest high or low peaks of surface height
along a given path.
|
| ScanExactlyNRidges3D(Avl.Surface, Avl.ScanMap, Avl.RidgeScanParams3D, int, Avl.Selection, float, Optional<float>, Optional<Avl.LocalBlindness>, Optional<int>, Conditional<List<Avl.SurfaceRidge1D>>, Optional<Avl.Profile>, Optional<Avl.Profile>) |
Locates a specified number of the strongest high or low peaks of surface height
along a given path.
|
| ScanExactlyNRidges_Direct(Avl.Image, Avl.Path, Optional<Avl.CoordinateSystem2D>, int, Avl.SamplingParams, Avl.RidgeScanParams, int, Avl.Selection, float, Optional<float>, Optional<Avl.LocalBlindness>, Conditional<List<Avl.Ridge1D>>, Conditional<List<Avl.Gap1D>>, Optional<Avl.Path>, Optional<Avl.Profile>, Optional<Avl.Profile>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Locates a specified number of the strongest dark or bright pixel peak along
a given path (without a scan map).
|
| ScanExactlyNRidges(Avl.Image, Avl.ScanMap, Avl.RidgeScanParams, int, Avl.Selection, float, Optional<float>, Optional<Avl.LocalBlindness>, Conditional<List<Avl.Ridge1D>>, Conditional<List<Avl.Gap1D>>, Optional<Avl.Profile>, Optional<Avl.Profile>) |
Locates a specified number of the strongest dark or bright pixel peak along
a given path.
|
| ScanExactlyNStripes3D_Direct(Avl.Surface, Avl.Path, Optional<Avl.CoordinateSystem2D>, Optional<float>, int, Avl.InterpolationMethod, Avl.StripeScanParams3D, int, Avl.Selection, float, Optional<float>, Optional<Avl.LocalBlindness>, Optional<int>, Conditional<List<Avl.SurfaceStripe1D>>, Optional<Avl.Path>, Optional<Avl.Profile>, Optional<Avl.Profile>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Locates a specified number of multiple pairs of changes of surface height along
a given path.
|
| ScanExactlyNStripes3D(Avl.Surface, Avl.ScanMap, Avl.StripeScanParams3D, int, Avl.Selection, float, Optional<float>, Optional<Avl.LocalBlindness>, Optional<int>, Conditional<List<Avl.SurfaceStripe1D>>, Optional<Avl.Profile>, Optional<Avl.Profile>) |
Locates a specified number of multiple pairs of changes of surface height along
a given path.
|
| ScanExactlyNStripes_Direct(Avl.Image, Avl.Path, Optional<Avl.CoordinateSystem2D>, int, Avl.SamplingParams, Avl.StripeScanParams, int, Avl.Selection, float, Optional<float>, Optional<Avl.LocalBlindness>, Conditional<List<Avl.Stripe1D>>, Conditional<List<Avl.Gap1D>>, Optional<Avl.Path>, Optional<Avl.Profile>, Optional<Avl.Profile>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Locates a specified number of multiple pairs of opposite edges across a given
path (without a scan map).
|
| ScanExactlyNStripes(Avl.Image, Avl.ScanMap, Avl.StripeScanParams, int, Avl.Selection, float, Optional<float>, Optional<Avl.LocalBlindness>, Conditional<List<Avl.Stripe1D>>, Conditional<List<Avl.Gap1D>>, Optional<Avl.Profile>, Optional<Avl.Profile>) |
Locates a specified number of multiple pairs of opposite edges across a given
path.
|
| ScanMultipleEdges3D_Direct(Avl.Surface, Avl.Path, Optional<Avl.CoordinateSystem2D>, Optional<float>, int, Avl.InterpolationMethod, Avl.EdgeScanParams3D, float, Optional<float>, Optional<Avl.LocalBlindness>, Optional<int>, List<Avl.SurfaceEdge1D>, Optional<Avl.Path>, Optional<Avl.Profile>, Optional<Avl.Profile>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Locates multiple changes of surface height along a given path.
|
| ScanMultipleEdges3D(Avl.Surface, Avl.ScanMap, Avl.EdgeScanParams3D, float, Optional<float>, Optional<Avl.LocalBlindness>, Optional<int>, List<Avl.SurfaceEdge1D>, Optional<Avl.Profile>, Optional<Avl.Profile>) |
Locates multiple changes of surface height along a given path.
|
| ScanMultipleEdges_Direct(Avl.Image, Avl.Path, Optional<Avl.CoordinateSystem2D>, int, Avl.SamplingParams, Avl.EdgeScanParams, float, Optional<float>, Optional<Avl.LocalBlindness>, List<Avl.Edge1D>, List<Avl.Gap1D>, Optional<Avl.Path>, Optional<Avl.Profile>, Optional<Avl.Profile>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Locates multiple transitions between dark and bright pixels along a given path
(without a scan map).
|
| ScanMultipleEdges(Avl.Image, Avl.ScanMap, Avl.EdgeScanParams, float, Optional<float>, Optional<Avl.LocalBlindness>, List<Avl.Edge1D>, List<Avl.Gap1D>, Optional<Avl.Profile>, Optional<Avl.Profile>) |
Locates multiple transitions between dark and bright pixels along a given path.
|
| ScanMultipleRidges3D_Direct(Avl.Surface, Avl.Path, Optional<Avl.CoordinateSystem2D>, Optional<float>, int, Avl.InterpolationMethod, Avl.RidgeScanParams3D, float, Optional<float>, Optional<Avl.LocalBlindness>, Optional<int>, List<Avl.SurfaceRidge1D>, Optional<Avl.Path>, Optional<Avl.Profile>, Optional<Avl.Profile>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Locates multiple high or low peaks of surface height along a given path.
|
| ScanMultipleRidges3D(Avl.Surface, Avl.ScanMap, Avl.RidgeScanParams3D, float, Optional<float>, Optional<Avl.LocalBlindness>, Optional<int>, List<Avl.SurfaceRidge1D>, Optional<Avl.Profile>, Optional<Avl.Profile>) |
Locates multiple high or low peaks of surface height along a given path.
|
| ScanMultipleRidges_Direct(Avl.Image, Avl.Path, Optional<Avl.CoordinateSystem2D>, int, Avl.SamplingParams, Avl.RidgeScanParams, float, Optional<float>, Optional<Avl.LocalBlindness>, List<Avl.Ridge1D>, List<Avl.Gap1D>, Optional<Avl.Path>, Optional<Avl.Profile>, Optional<Avl.Profile>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Locates multiple dark or bright pixel peaks along a given path (without a scan
map).
|
| ScanMultipleRidges(Avl.Image, Avl.ScanMap, Avl.RidgeScanParams, float, Optional<float>, Optional<Avl.LocalBlindness>, List<Avl.Ridge1D>, List<Avl.Gap1D>, Optional<Avl.Profile>, Optional<Avl.Profile>) |
Locates multiple dark or bright pixel peaks along a given path.
|
| ScanMultipleStripes3D_Direct(Avl.Surface, Avl.Path, Optional<Avl.CoordinateSystem2D>, Optional<float>, int, Avl.InterpolationMethod, Avl.StripeScanParams3D, float, Optional<float>, Optional<Avl.LocalBlindness>, Optional<int>, List<Avl.SurfaceStripe1D>, Optional<Avl.Path>, Optional<Avl.Profile>, Optional<Avl.Profile>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Locates multiple pairs of changes of surface height along a given path.
|
| ScanMultipleStripes3D(Avl.Surface, Avl.ScanMap, Avl.StripeScanParams3D, float, Optional<float>, Optional<Avl.LocalBlindness>, Optional<int>, List<Avl.SurfaceStripe1D>, Optional<Avl.Profile>, Optional<Avl.Profile>) |
Locates multiple pairs of changes of surface height along a given path.
|
| ScanMultipleStripes_Direct(Avl.Image, Avl.Path, Optional<Avl.CoordinateSystem2D>, int, Avl.SamplingParams, Avl.StripeScanParams, float, Optional<float>, Optional<Avl.LocalBlindness>, List<Avl.Stripe1D>, List<Avl.Gap1D>, Optional<Avl.Path>, Optional<Avl.Profile>, Optional<Avl.Profile>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Locates multiple pairs of edges across a given path (without a scan map).
|
| ScanMultipleStripes(Avl.Image, Avl.ScanMap, Avl.StripeScanParams, float, Optional<float>, Optional<Avl.LocalBlindness>, List<Avl.Stripe1D>, List<Avl.Gap1D>, Optional<Avl.Profile>, Optional<Avl.Profile>) |
Locates multiple pairs of edges across a given path.
|
| ScanSingleEdge3D_Direct(Avl.Surface, Avl.Path, Optional<Avl.CoordinateSystem2D>, Optional<float>, int, Avl.InterpolationMethod, Avl.EdgeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, Conditional<Avl.SurfaceEdge1D>, Optional<Avl.Path>, Optional<Avl.Profile>, Optional<Avl.Profile>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Locates the strongest change of surface height along a given path.
|
| ScanSingleEdge3D(Avl.Surface, Avl.ScanMap, Avl.EdgeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, Conditional<Avl.SurfaceEdge1D>, Optional<Avl.Profile>, Optional<Avl.Profile>) |
Locates the strongest change of surface height along a given path.
|
| ScanSingleEdge_Direct(Avl.Image, Avl.Path, Optional<Avl.CoordinateSystem2D>, int, Avl.SamplingParams, Avl.EdgeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, Conditional<Avl.Edge1D>, Optional<Avl.Path>, Optional<Avl.Profile>, Optional<Avl.Profile>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Locates the strongest transition between dark and bright pixels along a given
path (without a scan map).
|
| ScanSingleEdge(Avl.Image, Avl.ScanMap, Avl.EdgeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, Conditional<Avl.Edge1D>, Optional<Avl.Profile>, Optional<Avl.Profile>) |
Locates the strongest transition between dark and bright pixels along a given
path.
|
| ScanSingleRidge3D_Direct(Avl.Surface, Avl.Path, Optional<Avl.CoordinateSystem2D>, Optional<float>, int, Avl.InterpolationMethod, Avl.RidgeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, Conditional<Avl.SurfaceRidge1D>, Optional<Avl.Path>, Optional<Avl.Profile>, Optional<Avl.Profile>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Locates the strongest high or low peak of surface height along a given path.
|
| ScanSingleRidge3D(Avl.Surface, Avl.ScanMap, Avl.RidgeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, Conditional<Avl.SurfaceRidge1D>, Optional<Avl.Profile>, Optional<Avl.Profile>) |
Locates the strongest high or low peak of surface height along a given path.
|
| ScanSingleRidge_Direct(Avl.Image, Avl.Path, Optional<Avl.CoordinateSystem2D>, int, Avl.SamplingParams, Avl.RidgeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, Conditional<Avl.Ridge1D>, Optional<Avl.Path>, Optional<Avl.Profile>, Optional<Avl.Profile>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Locates the strongest dark or bright pixel peak along a given path (without
a scan map).
|
| ScanSingleRidge(Avl.Image, Avl.ScanMap, Avl.RidgeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, Conditional<Avl.Ridge1D>, Optional<Avl.Profile>, Optional<Avl.Profile>) |
Locates the strongest dark or bright pixel peak along a given path.
|
| ScanSingleStripe3D_Direct(Avl.Surface, Avl.Path, Optional<Avl.CoordinateSystem2D>, Optional<float>, int, Avl.InterpolationMethod, Avl.StripeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, Conditional<Avl.SurfaceStripe1D>, Optional<Avl.Path>, Optional<Avl.Profile>, Optional<Avl.Profile>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Locates the strongest pair of changes of surface height along a given path.
|
| ScanSingleStripe3D(Avl.Surface, Avl.ScanMap, Avl.StripeScanParams3D, Avl.Selection, Optional<Avl.LocalBlindness>, Optional<int>, Conditional<Avl.SurfaceStripe1D>, Optional<Avl.Profile>, Optional<Avl.Profile>) |
Locates the strongest pair of changes of surface height along a given path.
|
| ScanSingleStripe_Direct(Avl.Image, Avl.Path, Optional<Avl.CoordinateSystem2D>, int, Avl.SamplingParams, Avl.StripeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, Conditional<Avl.Stripe1D>, Optional<Avl.Path>, Optional<Avl.Profile>, Optional<Avl.Profile>, Diagnostic<List<Avl.Path>>, Diagnostic<float>) |
Locates the strongest pair of edges across a given path (without a scan map).
|
| ScanSingleStripe(Avl.Image, Avl.ScanMap, Avl.StripeScanParams, Avl.Selection, Optional<Avl.LocalBlindness>, Conditional<Avl.Stripe1D>, Optional<Avl.Profile>, Optional<Avl.Profile>) |
Locates the strongest pair of edges across a given path.
|
| sed(Avl.Point2D, Avl.Point2D) | |
| Segment2DToLine2D(Avl.Segment2D, Avl.Line2D) |
Converts a segment to a line.
|
| Segment2DToPath(Avl.Segment2D, Avl.Path) |
Converts a segment to a path.
|
| Segment2DToSegment3D_AxesPlane(Avl.Segment2D, Avl.PlaneType, float, Avl.Segment3D, Optional<Avl.Plane3D>) |
Projects a 2D segment onto a plane defined by 3D coordinate axes.
|
| Segment2DToSegment3D(Avl.Segment2D, Avl.Segment3D) |
Converts a segment in 2D to a segment in 3D.
|
| Segment3DBisector(Avl.Segment3D, Avl.Plane3D) |
Computes a plane passing through the center of a segment in 3D at a right angle.
|
| Segment3DBoundingBox(Avl.Segment3D, Avl.Box3D) |
Computes the smallest box in 3D containing a segment in 3D.
|
| Segment3DCenter(Avl.Segment3D, Avl.Point3D) |
Computes the center point of a segment in 3D.
|
| Segment3DLength(Avl.Segment3D, float) |
Computes the length of a segment in 3D.
|
| Segment3DLine(Avl.Segment3D, Avl.Line3D) |
Computes the line in 3D passing through a segment.
|
| Segment3DToLine3D(Avl.Segment3D, Avl.Line3D) |
Converts a segment in 3D to a line in 3D.
|
| Segment3DToPath(Avl.Segment3D, Avl.Path) |
Converts a segment in 3D to a path in 2D by ignoring its Z coordinates.
|
| Segment3DToSegment2D_AxesPlane(Avl.Segment3D, Avl.PlaneType, Avl.Segment2D, Optional<Avl.Plane3D>) |
Projects a 3D segment onto a plane defined by coordinate axes.
|
| Segment3DToSegment2D(Avl.Segment3D, Avl.Segment2D) |
Converts a segment in 3D to a segment in 2D by ignoring its Z coordinates.
|
| Segment3DVector(Avl.Segment3D, Avl.Vector3D) |
Returns the vector [x2 - x1, y2 - y1, z2 - z1].
|
| SegmentArcIntersection(Avl.Segment2D, Avl.Arc2D, Conditional<Avl.Point2D>, Conditional<Avl.Point2D>) |
Computes the common points of an arc and a segment.
|
| SegmentArrayIntersections(List<Avl.Segment2D>, List<Avl.Point2D>, List<int>, List<int>, List<Avl.Segment2D>, List<int>, List<int>) |
Computes a common points or segment of any segments from the set.
|
| SegmentBisector(Avl.Segment2D, Avl.Line2D) |
Computes a line passing through the center of a segment at a right angle.
|
| SegmentCenter(Avl.Segment2D, Avl.Point2D) |
Computes the center point of a segment.
|
| SegmentCircleIntersection(Avl.Segment2D, Avl.Circle2D, Conditional<Avl.Point2D>, Conditional<Avl.Point2D>) |
Computes the common points of a circle and a segment.
|
| SegmentImage_Color(Avl.Image, Optional<Avl.Region>, List<Avl.Pixel>, float, Optional<List<float>>, float, bool, List<Avl.Region>) |
Segments an image basing on distance to model colors.
|
| SegmentImage_Edges(Avl.Image, Optional<Avl.Region>, int, float, float, float, float, int, Optional<int>, bool, int, List<Avl.Region>, Optional<List<int>>, Diagnostic<Avl.Region>) |
Segments an image into blobs using image edges as their borders.
|
| SegmentImage_Gray_Linear(Avl.Image, Optional<Avl.Region>, Avl.BlobMergingMethod, Avl.RegionConnectivity, int, int, int, bool, int, Optional<int>, List<Avl.Region>) |
Segments an image into blobs examining differences between pixels values.
|
| SegmentImage_Gray_Tiled(Avl.Image, Optional<Avl.Region>, Avl.BlobMergingMethod, Avl.RegionConnectivity, int, int, bool, bool, int, Optional<int>, List<Avl.Region>) |
Segments an image into blobs examining differences between pixels values, first
pass is tiled.
|
| SegmentImage_Gray(Avl.Image, Optional<Avl.Region>, float, Avl.BlobsDifferenceMeasure, int, Optional<int>, List<Avl.Region>) |
Segments an image into blobs examining differences between neighbouring pixels
values.
|
| SegmentImage_Watersheds(Avl.Image, Optional<Avl.Region>, List<Avl.Region>, Avl.Polarity, List<Avl.Region>) |
Computes dark or bright watershed basins of an image.
|
| SegmentLength(Avl.Segment2D, float) |
Computes the length of a segment.
|
| SegmentLine(Avl.Segment2D, Avl.Line2D) |
Computes the line passing through a segment.
|
| SegmentNormalVector(Avl.Segment2D, bool, Avl.Vector2D) |
Computes an unitary vector perpendicular to the segment.
|
| SegmentOrientation(Avl.Segment2D, Avl.AngleRange, float) |
Computes the orientation of a segment.
|
| SegmentPath(Avl.Path, float, float, Avl.PathSegmentationMode, Optional<float>, List<Avl.Path>, List<Avl.Path>, List<Avl.Segment2D>, List<Avl.Arc2D>) |
Splits a path into parts that can be approximated as segments or arcs.
|
| SegmentPlaneIntersection3D(Avl.Segment3D, Avl.Plane3D, Conditional<Avl.Point3D>) |
Computes the intersection point of a segment in 3D and a plane.
|
| SegmentPoint3DGrid_PlanarCells(Avl.Point3DGrid, float, double, List<List<Avl.Point3D>>, Diagnostic<List<Avl.Segment3D>>, Diagnostic<List<Avl.Box3D>>) |
Computes a list of planar cells of a point cloud
|
| SegmentPoint3DGrid_Planes(Avl.Point3DGrid, float, double, int, float, float, List<List<Avl.Point3D>>, List<Avl.Plane3D>, Diagnostic<List<List<Avl.Point3D>>>) |
Segments a point cloud into planes.
|
| Segments2DToSegments3D_AxesPlane(List<Avl.Segment2D>, Avl.PlaneType, float, List<Avl.Segment3D>, Optional<Avl.Plane3D>) |
Projects an array of 2D segments onto a plane defined by 3D coordinate axes.
|
| Segments3DToSegments2D_AxesPlane(List<Avl.Segment3D>, Avl.PlaneType, List<Avl.Segment2D>, Optional<Avl.Plane3D>) |
Projects an array of 3D segments onto a plane defined by coordinate axes.
|
| SegmentSegmentIntersection(Avl.Segment2D, Avl.Segment2D, Conditional<Avl.Point2D>) |
Computes a common point of two segments.
|
| SegmentSurface_PlanarCells(Avl.Surface, Optional<Avl.Region>, int, Optional<int>, double, float, List<Avl.Region>, Diagnostic<List<Avl.Segment3D>>, Diagnostic<List<Avl.Region>>) |
Computes a list of planar cells of a surface
|
| SegmentSurface_Planes(Avl.Surface, Optional<Avl.Region>, int, Optional<int>, double, int, double, double, float, int, List<Avl.Region>, List<Avl.Plane3D>, Diagnostic<List<Avl.Region>>) |
Segments a surface into planes.
|
| SegmentToPlaneDistance3D(Avl.Segment3D, Avl.Plane3D, float, float, Optional<Avl.Segment3D>, Optional<float>) |
Measures the distance between a segment in 3D and a plane.
|
| SegmentToSegmentDistance3D(Avl.Segment3D, Avl.Segment3D, float, float, Optional<Avl.Segment3D>) |
Measures the distance between two segments in 3D.
|
| SegmentToSegmentDistance(Avl.Segment2D, Avl.Segment2D, float, float, Optional<Avl.Segment2D>) |
Measures the distance between two segments.
|
| SegmentVector(Avl.Segment2D, Avl.Vector2D) |
Returns the vector [x2 - x1, y2 - y1].
|
| SelectChannel(Avl.Image, Optional<Avl.Region>, int, Avl.Image) |
Creates an image from a single channel of the input image.
|
| SelectClosedPaths(List<Avl.Path>, List<Avl.Path>) |
Selects paths which are closed.
|
| SelectInnerPaths(List<Avl.Path>, Avl.Point2D, float, List<Avl.Path>) |
Selects paths which are visible from a point.
|
| SelectOpenPaths(List<Avl.Path>, List<Avl.Path>) |
Selects paths which are open.
|
| SelectOuterPaths(List<Avl.Path>, Avl.Point2D, float, List<Avl.Path>) |
Selects paths which do not obstruct visibility of other paths from a point.
|
| SelectRegions(List<Avl.Region>, Avl.RegionFeature, Optional<float>, Optional<float>, List<Avl.Region>, Optional<List<float>>) |
Selects regions according to the selected feature and range.
|
| SelectThresholdValue(Avl.Image, Optional<Avl.Region>, Avl.ThresholdSelectionMethod, float, Diagnostic<List<float>>, Diagnostic<List<float>>, Diagnostic<List<float>>) |
Selects best threshold value using the image histogram.
|
| SetHistogramBin(Avl.Histogram, int, bool, bool, double) |
Sets the value of a single histogram bin.
|
| SetHistogramCorrespondingBin(Avl.Histogram, float, bool, double) |
Selects a bin that the given value in the histogram domain falls into and sets
the value of this bin.
|
| SetImageColumn(Avl.Image, Optional<int>, int, List<float>) |
Sets pixel values in a single entire column of an image.
|
| SetImagePixels(Avl.Image, List<Avl.Location>, Avl.Pixel) |
Sets multiple pixels of an image to the selected value (all the pixels get the
same value).
|
| SetImagePixel(Avl.Image, Avl.Location, Avl.Pixel) |
Sets a pixel of an image to the selected value.
|
| SetImageRow(Avl.Image, Optional<int>, int, List<float>) |
Sets pixel values in a single entire row of an image.
|
| SetMultipleImagePixels(Avl.Image, List<Avl.Location>, List<Avl.Pixel>) |
Sets pixels of an image to the selected values (each pixel gets another value).
|
| SetParallelComputing(bool, int) | |
| SetPathCharacteristicPoint(Avl.Path, int, bool, Avl.Point2D) |
Modifies the value of a selected characteristic point.
|
| SetProfileElement(Avl.Profile, int, bool, float) |
Sets a single element in a profile, located at the specified index.
|
| SetProfileXTransform(Avl.Profile, float, float) |
Sets the offset and the scale of a profile in the X axis.
|
| SetRegionFrame(Avl.Region, int, int) |
Changes the width and the height of a region's frame (but does not rescale the
content).
|
| ShapeRegionToRegion(Avl.ShapeRegion, Avl.Region) |
Converts a shape region to a region with an automatically computed frame.
|
| SharpenImage(Avl.Image, float, Avl.KernelShape, int, Optional<int>, Avl.Image) |
Enhances contrast of an image so that it appears sharper.
|
| SharpenProfile(Avl.Profile, Optional<Avl.Range>, float, bool, Avl.Profile) |
Sharpens a profile using a 3x1 filter.
|
| ShearImage(Avl.Image, float, Avl.Axis, Avl.InterpolationMethod, Avl.Image) |
Computes a leant image (shifts the rows).
|
| ShearRegion(Avl.Region, float, Avl.Axis, Avl.Region) |
Computes a leant region.
|
| ShiftPath(Avl.Path, float, Avl.ShiftDirection, Avl.Path) |
Moves every vertex of path along bisector of the angle between incident segments.
|
| ShiftWorldPlane(Avl.RectificationTransform, double, Avl.RectificationTransform) |
Shifts world plane along its normal vector.
|
| ShrinkImageNTimes(Avl.Image, Optional<Avl.Box>, int, Optional<int>, Avl.Image) |
Shrinks an image by a natural factor along each axis.
|
| ShrinkProfileNTimes(Avl.Profile, int, Avl.Profile) |
Reduces the length of a profile N-times by averaging each N consecutive elements.
|
| ShrinkRegionNTimes(Avl.Region, int, Optional<int>, float, Avl.Region) |
Shrinks a region by a natural factor along each axis.
|
| signedDistance(Avl.Point2D, Avl.Line2D) | |
| SkeletonizeRegion(Avl.Region, Avl.RegionSkeletonMethod, Avl.Region) |
Thins a region to its skeleton.
|
| SkipEmptyBox3D(Avl.Box3D, Conditional<Avl.Box3D>, bool) |
If the input box in 3D has all dimensions different from zero, then it is copied
to the output; otherwise Nil is returned.
|
| SkipEmptyBox(Avl.Box, Conditional<Avl.Box>, bool) |
If the input box has both dimensions different from zero, then it is copied
to the output; otherwise Nil is returned.
|
| SkipEmptyDataHistogram(Avl.Histogram, Conditional<Avl.Histogram>, bool) |
If the input histogram contains any non-zero bin, then the histogram is copied
to the output; otherwise Nil is returned.
|
| SkipEmptyHistogram(Avl.Histogram, Conditional<Avl.Histogram>, bool) |
If the input histogram contains at least one bin, then it is copied to the output;
otherwise Nil is returned.
|
| SkipEmptyImage(Avl.Image, Conditional<Avl.Image>, bool) |
If the input image contains at least one pixel, then it is copied to the output;
otherwise Nil is returned.
|
| SkipEmptyPath(Avl.Path, Conditional<Avl.Path>, bool) |
If the input path has at least one point, then it is copied to the output; otherwise
Nil is returned.
|
| SkipEmptyPoint3DGrid(Avl.Point3DGrid, Conditional<Avl.Point3DGrid>, bool) |
If the input Point3DGrid has at least one point defined, then it is copied to
the output; otherwise Nil is returned.
|
| SkipEmptyProfile(Avl.Profile, Conditional<Avl.Profile>, bool) |
If the input profile contains at least one element, then it is copied to the
output; otherwise Nil is returned.
|
| SkipEmptyRegion(Avl.Region, Conditional<Avl.Region>, bool) |
If the input region contains at least one pixel, then it is copied to the output;
otherwise Nil is returned.
|
| SkipEmptySurfaceRegion(Avl.Surface, Avl.Region, Conditional<Avl.Region>, bool) |
If the input surface contains at least one valid point in a given region, then
the region is copied to the output; otherwise Nil is returned.
|
| SkipEmptySurface(Avl.Surface, Conditional<Avl.Surface>, bool) |
If the input Surface has at least one point defined, then it is copied to the
output; otherwise Nil is returned.
|
| SkipNotPolygon(Avl.Path, Conditional<Avl.Path>, bool) |
If the input path is closed and has no self-intersections, then it is copied
to the output; otherwise Nil is returned.
|
| SmoothHistogram_Gauss(Avl.Histogram, Optional<Avl.Range>, float, float, bool, Avl.Histogram) |
Smooths a histogram by averaging points within a kernel using gaussian-weighted
average.
|
| SmoothHistogram_Mean(Avl.Histogram, Optional<Avl.Range>, int, bool, Avl.Histogram) |
Smooths a histogram by averaging points within a kernel.
|
| SmoothImage_Bilateral(Avl.Image, Optional<Avl.Image>, Optional<Avl.Region>, float, float, Avl.BilateralSamplingMethod, int, Avl.Image) |
Smooths an image while preserving sharp edges.
|
| SmoothImage_Deriche(Avl.Image, Optional<Avl.Region>, float, Optional<float>, Avl.Image) |
Smooths an image using Deriche filter.
|
| SmoothImage_DirAndPresence(Avl.Image, int, Optional<int>, int, int, Avl.Image) |
Smooths the result of GradientDirAndPresenceImage.
|
| SmoothImage_Gauss_Mask(Avl.Image, Optional<Avl.Region>, Avl.GaussKernel, Avl.Image) |
Smooths an image using a predefined gaussian kernel.
|
| SmoothImage_Gauss(Avl.Image, Optional<Avl.Region>, float, Optional<float>, float, Avl.Image, Diagnostic<int>, Diagnostic<int>) |
Smooths an image using a gaussian kernel.
|
| SmoothImage_Mean_AnyKernel(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, Optional<Avl.Pixel>, Avl.Region, Optional<Avl.Location>, Avl.Image) |
Smooths an image by averaging pixels within an arbitrary kernel.
|
| SmoothImage_Mean_Mask(Avl.Image, Optional<Avl.Region>, Avl.MeanKernel, Avl.Image) |
Smooths an image by averaging pixels within a small rectangular kernel.
|
| SmoothImage_Mean(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, Optional<Avl.Pixel>, Avl.KernelShape, int, Optional<int>, Avl.Image) |
Smooths an image by averaging pixels within a rectangular kernel.
|
| SmoothImage_Median_Mask(Avl.Image, Optional<Avl.Region>, Avl.Image) |
Replaces each pixel with the median of pixels within a 3x3 rectangular kernel
(faster).
|
| SmoothImage_Median(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, Avl.SmoothImageMedianKernel, int, Optional<int>, Avl.Image) |
Replaces each pixel with the median of pixels within a kernel.
|
| SmoothImage_Middle(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, Optional<Avl.Pixel>, Avl.KernelShape, int, Optional<int>, Avl.Image) |
Replaces each pixel with the average of maximum and minimum calculated within
a kernel.
|
| SmoothImage_Quantile(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, float, Avl.SmoothImageMedianKernel, int, Optional<int>, Avl.Image) |
Replaces each pixel with a quantile of pixels within a kernel.
|
| SmoothPath_Gauss(Avl.Path, float, float, Avl.Path) |
Smooths a path by averaging its characteristic points within a kernel using
gaussian-weighted average.
|
| SmoothPath_Mean(Avl.Path, int, Avl.Path) |
Smooths a path by averaging its characteristic points within a kernel.
|
| SmoothProfile_Gauss_Mask(Avl.Profile, float, Avl.Profile) |
Smooths a profile by averaging points with one of ten pre-computed Gauss kernels.
|
| SmoothProfile_Gauss(Avl.Profile, Optional<Avl.Range>, float, float, bool, Avl.Profile) |
Smooths a profile by averaging points within a kernel using gaussian-weighted
average.
|
| SmoothProfile_Mean(Avl.Profile, Optional<Avl.Range>, int, bool, Avl.Profile) |
Smooths a profile by averaging points within a kernel.
|
| SmoothRegion_Mean(Avl.Region, int, Optional<int>, Avl.Image) |
Smooths an region by averaging pixels within a rectangular kernel.
|
| SmoothSurface_Gauss(Avl.Surface, Optional<Avl.Region>, float, Optional<float>, float, Avl.Surface, Diagnostic<int>, Diagnostic<int>) |
Smooths a surface using a gaussian kernel.
|
| SmoothSurface_Mean(Avl.Surface, Optional<Avl.Region>, Avl.KernelShape, int, Optional<int>, Avl.Surface) |
Smooths a surface by averaging heights within a rectangular kernel.
|
| SortPaths(List<Avl.Path>, Avl.PathFilter, Avl.PathFeature, Avl.SortingOrder, List<Avl.Path>, Optional<List<float>>) |
Changes the order of paths from the input array according to an ascending/descending
sequence of their computed feature values.
|
| SortRegions(List<Avl.Region>, Avl.RegionFeature, Avl.SortingOrder, List<Avl.Region>, Optional<List<float>>) |
Changes the order of regions from the input array according to an ascending/descending
sequence of their computed feature values.
|
| SparseImageToRegion(Avl.SparseImage, Avl.Region) |
Converts a sparse region to a region.
|
| SplitBayerImage(Avl.Image, Avl.Image, Avl.Image, Avl.Image, Avl.Image) |
Creates several monochromatic images from individual pixels of the input Bayer
pattern image.
|
| SplitBox(Avl.Box, Avl.SplitDirection, Avl.Box, Avl.Box) |
Splits a box into two along a direction.
|
| SplitChannels_OrNil(Avl.Image, Optional<Conditional<Avl.Image>>, Optional<Conditional<Avl.Image>>, Optional<Conditional<Avl.Image>>, Optional<Conditional<Avl.Image>>) |
Creates several monochromatic images from individual channels of the input image
and sets Nil for channels that are not present.
|
| SplitChannels(Avl.Image, Optional<Avl.Image>, Optional<Avl.Image>, Optional<Avl.Image>, Optional<Avl.Image>) |
Creates several monochromatic images from individual channels of the input image.
|
| SplitPathByLine(Avl.Path, Avl.Line2D, List<Avl.Path>) |
Splits path in common points of a path and a line.
|
| SplitPathByPath(Avl.Path, Avl.Path, List<Avl.Path>) |
Splits path in common points of two paths.
|
| SplitPathBySegment(Avl.Path, Avl.Segment2D, List<Avl.Path>) |
Splits path in common points of a path and a segment.
|
| SplitPoint3DGridByPlane(Avl.Point3DGrid, Optional<Avl.Region>, Avl.Plane3D, Avl.Point3DGrid, Avl.Point3DGrid) |
Separates the points being on one side of the input plane from the others.
|
| SplitPointsByLine(List<Avl.Point2D>, Avl.Line2D, List<Avl.Point2D>, List<Avl.Point2D>) |
Separates the points being on one side of the input line from the others.
|
| SplitPointsByPlane(List<Avl.Point3D>, Avl.Plane3D, List<Avl.Point3D>, List<Avl.Point3D>) |
Separates the points being on one side of the input plane from the others.
|
| SplitRectangle(Avl.Rectangle2D, Avl.SplitDirection, Avl.Rectangle2D, Avl.Rectangle2D) |
Splits the rectangle into two along the direction.
|
| SplitRegionIntoBlobs(Avl.Region, Avl.RegionConnectivity, int, Optional<int>, bool, List<Avl.Region>) |
Splits a region into an array of regions corresponding to its connected components.
|
| SplitRegionIntoComponents(Avl.Region, Optional<int>, float, Optional<float>, Optional<int>, Optional<int>, int, Optional<int>, bool, List<Avl.Region>) |
Splits a region into an array of regions. Operates by merging blobs in accordance
to the inMaxDistance parameter.
|
| SplitRegionIntoExactlyNCharacters(Avl.Region, int, int, float, Conditional<List<Avl.Region>>, Diagnostic<List<Avl.Region>>, Diagnostic<Avl.Profile>) |
Splits the input region into a fixed-size array of regions corresponding to
individual characters.
|
| SplitRegionIntoExactlyNComponents(Avl.Region, int, Optional<int>, float, Optional<float>, Optional<int>, Optional<int>, bool, Conditional<List<Avl.Region>>) |
Splits a region into a fixed-size array of regions.
|
| SplitRegionIntoMultipleCharacters(Avl.Region, float, int, List<Avl.Region>, Diagnostic<List<Avl.Region>>, Diagnostic<Avl.Profile>) |
Splits the input region into an array of regions corresponding to individual
characters.
|
| SplitSegment(Avl.Segment2D, int, List<Avl.Segment2D>) |
Splits a segment into several parts of equal length.
|
| SplitSurfaceByPlane(Avl.Surface, Optional<Avl.Region>, Avl.Plane3D, bool, Avl.Surface, Avl.Surface) |
Separates the surface points being on one side of the input plane from the others.
|
| SquareImage(Avl.Image, Optional<Avl.Region>, Avl.Image) |
Raises pixel values to the second power pixel by pixel.
|
| SquareRootImage(Avl.Image, Optional<Avl.Region>, Avl.Image) |
Transforms pixel values to their square roots pixel by pixel.
|
| StandardDeviationImage(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, int, Avl.Image) |
Creates image of pixels' local standard deviations.
|
| Statistics_OfArray(List<float>, int, bool, Optional<float>, Optional<float>, Optional<float>, Optional<float>, Optional<float>, Optional<float>, Optional<float>) |
Computes basic statistical information out of an array of real numbers. The
array must be not empty.
|
| Statistics_OfLoop(Avl.Statistics_OfLoopState, float, int, int, bool, Optional<float>, Optional<float>, Optional<float>, Optional<float>, Optional<float>, Optional<float>, Optional<float>) |
Computes basic statistical information out of real numbers appearing in consecutive
iterations.
|
| StretchPath(Avl.Path, Avl.Point2D, Avl.Point2D, Avl.Path) |
Moves, rotates and scales the path so that its end-points end up at the given
two points.
|
| StringLabelToString(Avl.StringLabel, string) |
Converts a StringLabel object to a String.
|
| StringToClassifyObjectModelDirectory(string, string) |
Conversion between Directory and ClassifyObjectModelDirectory
|
| StringToDetectAnomalies1ModelDirectory(string, string) |
Conversion between String and DetectAnomalies1ModelDirectory
|
| StringToDetectAnomalies2ModelDirectory(string, string) |
Conversion between String and DetectAnomalies2ModelDirectory
|
| StringToDetectFeaturesModelDirectory(string, string) |
Conversion between String and DetectFeaturesModelDirectory
|
| StringToGrammarRulesPattern(string, string) |
Conversion between String and GrammarRulesPattern
|
| StringToLocatePointsModelDirectory(string, string) |
Conversion between String and LocatePointsModelDirectory
|
| StringToSegmentInstancesModelDirectory(string, string) |
Conversion between String and SegmentInstancesModelDirectory
|
| Stripe1DToSegment2D(Avl.Stripe1D, Avl.Segment2D) |
Converts a stripe to a segment.
|
| Subpath(Avl.Path, int, int, Avl.Path) |
Creates an open path from a continuous subsequence of the input path's points.
|
| SubtractFromHistogram(Avl.Histogram, double, Avl.Histogram) |
Decreases each bin value by a number.
|
| SubtractFromImage(Avl.Image, Optional<Avl.Region>, float, Avl.Image) |
Subtracts a scalar value from each pixel.
|
| SubtractFromProfile(Avl.Profile, Optional<Avl.Range>, float) |
Subtracts a scalar value from each element of a profile.
|
| SubtractHistograms(Avl.Histogram, Avl.Histogram, Avl.Histogram) |
Subtracts two histograms bar by bar.
|
| SubtractImages_Signed(Avl.Image, Avl.Image, Optional<Avl.Region>, float, Avl.Image) |
Subtracts two images pixel by pixel. The result is signed.
|
| SubtractImages(Avl.Image, Avl.Image, Optional<Avl.Region>, float, Avl.Image) |
Subtracts two images pixel by pixel.
|
| SubtractProfiles(Avl.Profile, Avl.Profile, Avl.Profile) |
Subtracts two profiles value by value.
|
| SubtractSurfaces(Avl.Surface, Avl.Surface, Optional<Avl.Region>, Avl.Surface) |
Subtracts two surfaces point by point.
|
| SurfaceArea(Avl.Surface, float) |
Computes the surface area of given surface.
|
| SurfaceBoundingBox_OrNil(Avl.Surface, Optional<Avl.Region>, Conditional<Avl.Box3D>) |
Computes the bounding box 3D of given surface; returns NIL if no valid point
is present.
|
| SurfaceBoundingBox(Avl.Surface, Optional<Avl.Region>, Avl.Box3D) |
Computes the bounding box 3D of given surface.
|
| SurfaceBoxToImageCoordinates(Avl.Box3D, Avl.SurfaceCoordinatesFormat, Avl.Box, Optional<Avl.Rectangle2D>) |
Finds the associated image coordinates of surface box.
|
| SurfaceBoxToRegion(Avl.Box3D, Avl.SurfaceFormat, Avl.Region) |
Finds the surface region covered by surface box.
|
| SurfaceCircleToImageCoordinates(Avl.Circle3D, Avl.SurfaceCoordinatesFormat, Avl.Circle2D) |
Finds the associated image coordinates of surface circle.
|
| SurfaceCircleToRegion(Avl.Circle3D, Avl.SurfaceFormat, Avl.Region) |
Finds the surface region covered by surface circle.
|
| SurfaceCoordinateSystemToImageCoordinates(Avl.CoordinateSystem2D, Avl.SurfaceCoordinatesFormat, Avl.CoordinateSystem2D) |
Finds the associated image coordinates of surface coordinate system.
|
| SurfaceFlatness(Avl.Surface, Optional<Avl.Region>, Avl.Plane3D, Avl.Point3D, Avl.Point3D, float, float, float) |
Computes the surface flatness i.e. how thick the surface is according to the
input plane.
|
| SurfaceFormatToSurfaceCoordinatesFormat(Avl.SurfaceFormat, Avl.SurfaceCoordinatesFormat) |
Converts a surface format to a surface coordinates format.
|
| SurfaceLineToImageCoordinates(Avl.Line3D, Avl.SurfaceCoordinatesFormat, Avl.Line2D) |
Finds the associated image coordinates of surface line.
|
| SurfaceLocalMaxima(Avl.Surface, Optional<Avl.Region>, bool, Optional<float>, Optional<float>, float, Optional<Avl.SurfaceLocalExtremaVerification>, Optional<List<Avl.SurfaceExtremum>>, Optional<List<Avl.Region>>) |
Finds surface locations characterized by locally maximal heights.
|
| SurfaceLocalMinima(Avl.Surface, Optional<Avl.Region>, bool, Optional<float>, Optional<float>, float, Optional<Avl.SurfaceLocalExtremaVerification>, Optional<List<Avl.SurfaceExtremum>>, Optional<List<Avl.Region>>) |
Finds surface locations characterized by locally minimal heights.
|
| SurfaceMassCenter_OrNil(Avl.Surface, Optional<Avl.Region>, Conditional<Avl.Point3D>) |
Computes the mass center of surface points; returns NIL if the surface is empty
in the given region.
|
| SurfaceMassCenter(Avl.Surface, Optional<Avl.Region>, Avl.Point3D) |
Computes the mass center of surface points.
|
| SurfaceMaximalPoint(Avl.Surface, Optional<Avl.Region>, Avl.Point3D) |
Finds the surface point with maximal Z coordinate.
|
| SurfaceMedian_OrNil(Avl.Surface, Optional<Avl.Region>, Conditional<float>) |
Finds the median Z coordinate of the surface points; returns NIL if the surface
is empty in the given region.
|
| SurfaceMedian(Avl.Surface, Optional<Avl.Region>, float) |
Finds the median Z coordinate of the surface points.
|
| SurfaceMinimalPoint(Avl.Surface, Optional<Avl.Region>, Avl.Point3D) |
Finds the surface point with minimal Z coordinate.
|
| SurfaceMultiplePointsAlongAxis(Avl.Surface, Optional<Avl.Surface>, Avl.Axis, Optional<double>, Optional<double>, Optional<double>, int, Optional<double>, Optional<double>, Optional<int>, List<List<Avl.Point3D>>, Optional<List<double>>) |
Returns multiple arrays of surface points along X or Y axis.
|
| SurfaceMultipleProfilesAlongAxis(Avl.Surface, Avl.Axis, Optional<double>, Optional<double>, Optional<double>, int, Optional<double>, Optional<double>, Optional<int>, float, List<Avl.Profile>, Optional<List<double>>) |
Creates the profiles of point Z values along X or Y axis.
|
| SurfaceNormalsImage(Avl.Surface, Optional<Avl.Region>, float, Avl.Image, Optional<Avl.Region>) |
Computes a normals image for a surface
|
| SurfacePathsToImageCoordinates(List<Avl.Path>, Avl.SurfaceCoordinatesFormat, List<Avl.Path>) |
Finds the associated image coordinates of surface paths.
|
| SurfacePathToImageCoordinates(Avl.Path, Avl.SurfaceCoordinatesFormat, Avl.Path) |
Finds the associated image coordinates of surface path.
|
| SurfacePathToRegion(Avl.Path, Avl.SurfaceFormat, Avl.Region) |
Finds the surface region covered by surface path.
|
| SurfacePointsToImageCoordinates(List<Avl.Point3D>, Avl.SurfaceCoordinatesFormat, List<Avl.Point2D>) |
Finds the associated image coordinates of surface points.
|
| SurfacePointToImageCoordinates(Avl.Point3D, Avl.SurfaceCoordinatesFormat, Avl.Point2D) |
Finds the associated image coordinates of surface point.
|
| SurfaceProfileAlongPath(Avl.ScanMapState, Avl.Surface, Avl.Path, Optional<Avl.CoordinateSystem2D>, Optional<float>, int, Avl.InterpolationMethod, Optional<int>, float, Avl.Profile, Avl.Path, Optional<Avl.Path>, Diagnostic<List<Avl.Path>>) |
Creates a series of segments across the input path, measures the average surface
height on each of the segments, and creates the final profile from those values.
|
| SurfaceSegmentsToImageCoordinates(List<Avl.Segment3D>, Avl.SurfaceCoordinatesFormat, List<Avl.Segment2D>) |
Finds the associated image coordinates of surface segments.
|
| SurfaceSegmentToImageCoordinates(Avl.Segment3D, Avl.SurfaceCoordinatesFormat, Avl.Segment2D) |
Finds the associated image coordinates of surface segment.
|
| SurfaceSinglePointsAlongAxis(Avl.Surface, Optional<Avl.Surface>, Avl.Axis, double, int, Optional<double>, Optional<double>, Optional<int>, List<Avl.Point3D>, Optional<double>) |
Returns single array of surface points along X or Y axis.
|
| SurfaceSingleProfileAlongAxis(Avl.Surface, Avl.Axis, double, int, Optional<double>, Optional<double>, Optional<int>, float, Avl.Profile, Optional<double>) |
Creates the profile of point Z values along X or Y axis.
|
| SurfaceToImage(Avl.Surface, Avl.Image) |
Converts a surface object to an image.
|
| SurfaceToPlaneDistanceImage(Avl.Surface, Optional<Avl.Region>, Avl.Plane3D, float, bool, Avl.Image) |
Computes the image of the distances of the input surface points from a given
plane.
|
| SurfaceToPoint3DArray(Avl.Surface, List<Avl.Point3D>) |
Converts a surface object to an array of points removing nonexistent ones.
|
| SurfaceToPoint3DGrid(Avl.Surface, Avl.Point3DGrid) |
Converts a surface object to a grid of points.
|
| SurfaceToSurfaceCoordinatesFormat(Avl.Surface, Avl.SurfaceCoordinatesFormat) |
Converts a surface to a surface coordinates format.
|
| SurfaceToSurfaceFormat(Avl.Surface, Avl.SurfaceFormat) |
Converts a surface to a surface format.
|
| SurfaceValidPointsRegion(Avl.Surface, Optional<Avl.Region>, Avl.Region, Avl.Region) |
Computes region of locations where points are valid in a surface and where they
are invalid.
|
| SurfaceVectorToImageCoordinates(Avl.Vector3D, Avl.SurfaceCoordinatesFormat, Avl.Vector2D) |
Finds the associated image coordinates of surface vector.
|
| SurfaceVolume_Double(Avl.Surface, Avl.Surface, Optional<Avl.Region>, Avl.VolumeCalculationMethod, double) |
Computes the volume of a surface with respect to another surface.
|
| SurfaceVolume_Single(Avl.Surface, double, Optional<Avl.Region>, Avl.VolumeCalculationMethod, double, Optional<Avl.Plane3D>) |
Computes the volume of a surface with respect to a plane.
|
| SVM_ClassifyMultiple(Avl.SvmModel, List<List<float>>, List<int>, Optional<List<int>>, Optional<List<List<float>>>) |
Classifies input points based on trained model.
|
| SVM_ClassifySingle(Avl.SvmModel, List<float>, int, Optional<List<int>>, Optional<List<float>>) |
Classifies input features based on a trained model.
|
| SVM_Init(Optional<float>, float, float, Optional<float>, float, bool, Avl.SvmModel) |
Initializes an SVM model.
|
| SVM_Train(Avl.SvmModel, List<List<float>>, List<int>, Avl.SvmModel, float) |
Trains an SVM model.
|
| TableOfConfusion_Basic(long, long, long, long, Avl.ConfusionTable) |
Computes statistics from a confusion matrix for given TP, FP, TN, FN.
|
| TableOfConfusion_BoolArray(List<bool>, List<bool>, long, long, long, long, Avl.ConfusionTable) |
Computes statistics from a confusion matrix for an array of groundTruth and
results.
|
| TableOfConfusion_Histograms(Avl.Histogram, Avl.Histogram, float, Avl.ConfusionTable) |
Computes confusion matrix based on two histograms and threshold value.
|
| TableOfConfusion_Images(Avl.Image, Avl.Image, int, long, long, long, long, Avl.ConfusionTable) |
Computes statistics from a confusion matrix for image of groundTruth and results.
|
| TelecentricCameraModelToAnyCameraModel(Avl.TelecentricCameraModel, Avl.AnyCameraModel) |
Conversion
|
| TelecentricCameraModelToRectificationTransform(Avl.TelecentricCameraModel, Avl.RectificationTransform) |
Conversion
|
| TensorDataTypeSize(Avl.TensorDataType) | |
| TestBox3DEmpty(Avl.Box3D, bool) |
Tests whether the box in 3D is empty.
|
| TestBox3DInBox3D(Avl.Box3D, Avl.Box3D, bool) |
Tests whether a box in 3D is contained in another one.
|
| TestBox3DIntersectsWith(Avl.Box3D, Avl.Box3D, bool) |
Tests whether two boxes in 3D have non-empty intersection.
|
| TestBox3DNotEmpty(Avl.Box3D, bool) |
Tests whether the box in 3D is not empty.
|
| TestBoxEmpty(Avl.Box, bool) |
Tests whether the box is empty.
|
| TestBoxEqualTo(Avl.Box, Avl.Box, bool) |
Tests whether given boxes are equal.
|
| TestBoxInBox(Avl.Box, Avl.Box, bool) |
Tests whether a box is contained in another one.
|
| TestBoxInImage(Avl.Image, Avl.Box, bool) |
Tests whether a box is contained in the dimensions of an image.
|
| TestBoxIntersectsWith(Avl.Box, Avl.Box, bool) |
Tests whether two boxes have non-empty intersection.
|
| TestBoxNotEmpty(Avl.Box, bool) |
Tests whether the box is not empty.
|
| TestHistogramDominatesHistogram(Avl.Histogram, Avl.Histogram, bool) |
Checks whether the values in the first histogram are greater or equal than corresponding
values in the second histogram.
|
| TestImageEqualTo(Avl.Image, Avl.Image, bool) |
Tests whether two images equal.
|
| TestImage(Avl.TestImageId, Optional<Avl.Image>, Optional<Avl.Image>) |
Returns a sample image.
|
| TestLine3DThroughCircle3D(Avl.Line3D, Avl.Circle3D, bool) |
Tests whether a line in 3D goes through a circle in 3D.
|
| TestLocationInBox(Avl.Location, Avl.Box, bool) |
Tests whether a location is contained in the dimensions of a box.
|
| TestLocationInImage(Avl.Image, Avl.Location, bool) |
Tests whether a location is contained in the dimensions of an image.
|
| TestPoint3DGrid(Avl.TestPoint3DGridState, float, float, float, float, Avl.Point3DGrid) |
Returns a sample 3D object.
|
| TestPoint3DInBox3D(Avl.Point3D, Avl.Box3D, bool) |
Tests whether a point in 3D lies in a box in 3D.
|
| TestPointArrayInBox(List<Avl.Point2D>, Avl.Box, List<bool>, Optional<List<Avl.Point2D>>, Optional<bool>) |
Tests which points lie inside a box.
|
| TestPointArrayInPolygon(List<Avl.Point2D>, Avl.Path, List<bool>, List<Avl.Point2D>, Optional<bool>) |
Tests which points lie inside a polygon.
|
| TestPointArrayInRectangle(List<Avl.Point2D>, Avl.Rectangle2D, List<bool>, Optional<List<Avl.Point2D>>, Optional<bool>) |
Tests which points lie inside a rectangle.
|
| TestPointArrayInRegion(List<Avl.Point2D>, Avl.Region, List<bool>, Optional<List<Avl.Point2D>>, Optional<bool>) |
Tests which points lie inside a region.
|
| TestPointInBox(Avl.Point2D, Avl.Box, bool) |
Tests whether a point lies in a box.
|
| TestPointInCircle(Avl.Point2D, Avl.Circle2D, bool) |
Tests whether a point lies inside a circle.
|
| TestPointInImage(Avl.Image, Avl.Point2D, bool) |
Tests whether a point is contained in the dimensions of an image.
|
| TestPointInPolygon(Avl.Point2D, Avl.Path, bool) |
Tests whether a point lies inside a polygon.
|
| TestPointInRectangle(Avl.Point2D, Avl.Rectangle2D, bool) |
Tests whether a point lies in a rectangle.
|
| TestPointInRegion(Avl.Point2D, Avl.Region, bool) |
Tests whether a point lies inside a region.
|
| TestPolygonConvex(Avl.Path, bool) |
Tests whether a polygon is convex.
|
| TestPolygonInPolygon(Avl.Path, Avl.Path, bool) |
Tests whether a polygon lies inside another one.
|
| TestProfileDominatesProfile(Avl.Profile, Avl.Profile, bool) |
Checks whether values in the first profile are greater or equal than corresponding
values in the second profile.
|
| TestProfileEqualTo(Avl.Profile, Avl.Profile, bool) |
Checks whether profiles are exactly equals.
|
| TestRectangleInImage(Avl.Image, Avl.Rectangle2D, bool) |
Tests whether a rectangle is contained in the dimensions of an image.
|
| TestRectangleIntersectsWith(Avl.Rectangle2D, Avl.Rectangle2D, bool) |
Tests if two rectangles intersect.
|
| TestRegionEmpty(Avl.Region, bool) |
Tests whether the size of a region equals zero.
|
| TestRegionEqualTo(Avl.Region, Avl.Region, bool) |
Tests whether given regions are equal.
|
| TestRegionInRegion(Avl.Region, Avl.Region, bool) |
Tests whether a region is contained in another one.
|
| TestRegionIntersectsWith(Avl.Region, Avl.Region, bool) |
Tests whether two regions have non-empty intersection.
|
| TestRegionNotEmpty(Avl.Region, bool) |
Tests whether the size of a region doesn't equal zero.
|
| TestRegionOnBorder(Avl.Region, bool) |
Tests whether a region is adjacent to its border.
|
| TestRegionUnequalTo(Avl.Region, Avl.Region, bool) |
Tests whether given regions are not equal.
|
| TestSpatialMapApplicability(Avl.Image, Avl.SpatialMap, bool) |
Checks if a spatial map may be applied to transform the given image.
|
| TestSurface(Avl.TestSurfaceState, Avl.PlainType, float, float, float, float, Avl.Surface) |
Returns a sample 3D surface.
|
| ThickenRegion(Avl.Region, Avl.Region) |
Performs a morphological thickening on a region using predefined kernels.
|
| ThinRegion(Avl.Region, Avl.Region) |
Performs a morphological thinning on a region using predefined kernels.
|
| ThresholdImage_Color(Avl.Image, Optional<Avl.Region>, Avl.Pixel, float, float, float, Avl.Image) |
Transforms each pixel value to maximum or minimum depending on the distance
from a given color.
|
| ThresholdImage_Dynamic(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, Avl.ThresholdDynamicReferenceMethod, Avl.KernelShape, int, Optional<int>, Optional<float>, Optional<float>, float, Avl.Image, Diagnostic<Avl.Image>) |
Thresholds an image relatively to some value calculated in a local rectangular
neighbourhood.
|
| ThresholdImage_HSx(Avl.Image, Optional<Avl.Region>, Avl.HSxColorModel, int, int, Optional<int>, Optional<int>, Optional<int>, Optional<int>, float, Avl.Image, Diagnostic<Avl.Image>) |
Transforms each pixel value to minimum or maximum depending on whether it belongs
to specified region in the HSV, HSL or HSI color space.
|
| ThresholdImage_Hysteresis(Avl.Image, Optional<Avl.Region>, Optional<float>, Optional<float>, float, Avl.Image) |
Thresholds an image with a hysteresis, i.e. with a lower threshold for neighboring
pixels.
|
| ThresholdImage_Multirange(Avl.Image, Optional<Avl.Region>, Optional<float>, Optional<float>, Optional<float>, Optional<float>, Optional<float>, Optional<float>, Optional<float>, Optional<float>, Avl.Image) |
Transforms each pixel value to maximum or minimum depending on whether they
belong to the specified range.
|
| ThresholdImage_Relative(Avl.Image, Optional<Avl.Region>, Avl.Image, Optional<float>, Optional<float>, float, Avl.Image) |
Thresholds an image with a different threshold value for each pixel (inBaseImage(x,
y) + inValue).
|
| ThresholdImage_RGB(Avl.Image, Optional<Avl.Region>, Optional<int>, Optional<int>, Optional<int>, Optional<int>, Optional<int>, Optional<int>, Optional<int>, Optional<int>, float, Avl.Image) |
Transforms each pixel value to minimum or maximum depending on whether it belongs
to the specified range for each individual pixel component.
|
| ThresholdImage(Avl.Image, Optional<Avl.Region>, Optional<float>, Optional<float>, float, Avl.Image) |
Transforms each pixel value to maximum or minimum depending on whether they
belong to the specified range.
|
| ThresholdSmoothedRegion_Mean(Avl.Region, int, Optional<int>, float, int, Avl.Region) |
Returns region of pixels witch collect minAmount of pixels in rectangle in input
region.
|
| ThresholdToRegion_Color(Avl.Image, Optional<Avl.Region>, Avl.Pixel, float, float, float, Avl.Region) |
Creates a region containing image pixels with values close to the given color.
|
| ThresholdToRegion_Dynamic(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, int, Optional<int>, Optional<float>, Optional<float>, float, Avl.Region, Diagnostic<Avl.Image>) |
Thresholds an image relatively to the average pixel value in a local rectangular
neighborhood.
|
| ThresholdToRegion_HSx(Avl.Image, Optional<Avl.Region>, Avl.HSxColorModel, int, int, Optional<int>, Optional<int>, Optional<int>, Optional<int>, Avl.Region, Diagnostic<Avl.Image>) |
Creates a region containing image pixels which belongs to specified region in
HSV, HSL or HSI space.
|
| ThresholdToRegion_Relative_DarkBright(Avl.Image, Optional<Avl.Region>, Avl.Image, float, float, float, Avl.Region, Avl.Region) |
Thresholds an image using two relative thresholds and produces two regions (Dark
and Bright) in a single image pass.
|
| ThresholdToRegion_Relative(Avl.Image, Optional<Avl.Region>, Avl.Image, Optional<float>, Optional<float>, float, Avl.Region) |
Thresholds an image with a different threshold value for each pixel (inBaseImage(x,
y) + inValue).
|
| ThresholdToRegion_RGB(Avl.Image, Optional<Avl.Region>, Optional<int>, Optional<int>, Optional<int>, Optional<int>, Optional<int>, Optional<int>, Optional<int>, Optional<int>, Avl.Region) |
Creates a region containing image pixels which belongs to the specified range
for each individual pixel component.
|
| ThresholdToRegion(Avl.Image, Optional<Avl.Region>, Optional<float>, Optional<float>, float, Avl.Region) |
Creates a region containing image pixels with values within the specified range.
|
| ThrowIfCurrentWorkCancelled() | |
| TopHatImage_AnyKernel(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, Optional<Avl.Pixel>, Avl.Region, Optional<Avl.Location>, Avl.Image) |
Performs a morphological white top hat operation on a image using an arbitrary
kernel.
|
| TopHatImage_Mask(Avl.Image, Optional<Avl.Region>, Optional<Avl.Pixel>, Avl.MorphologyKernel, Avl.Image) |
Performs a morphological white top hat operation on a image using a predefined
mask.
|
| TopHatImage(Avl.Image, Optional<Avl.Region>, Optional<Avl.Region>, Optional<Avl.Pixel>, Avl.KernelShape, int, Optional<int>, Avl.Image, Diagnostic<Avl.Region>) |
Performs a morphological white top hat operation on a image using a predefined
kernel.
|
| TopHatRegion_AnyKernel(Avl.Region, Avl.Region, Avl.Region) |
Performs a morphological white top hat operation on a region using an arbitrary
kernel.
|
| TopHatRegion(Avl.Region, Avl.KernelShape, int, Optional<int>, Avl.Region) |
Performs a morphological white top hat operation on a region using a predefined
kernel.
|
| ToString() | Inherited from System.Object |
| toward(Avl.Point2D, Avl.Point2D, float) | |
| TrainOcr_MLP(List<Avl.CharacterSample>, Avl.Size, Optional<List<int>>, Optional<int>, Avl.CharacterFeatures, float, float, int, Optional<Avl.Size>, Avl.OcrModel, float, Diagnostic<Avl.Profile>, Diagnostic<List<Avl.Image>>) |
Trains an OCR multilayer perceptron classifier.
|
| TrainOcr_SVM(List<Avl.CharacterSample>, Avl.Size, Optional<float>, Optional<float>, float, float, bool, Optional<Avl.Size>, Optional<int>, Avl.CharacterFeatures, Avl.OcrModel, float, Diagnostic<List<Avl.Image>>) |
Trains an OCR support vector machines classifier.
|
| TransformCircle3D(Avl.Circle3D, Avl.Matrix, bool, Avl.Circle3D) |
Applies a general transformation expressed by a matrix to a 3D circle.
|
| TransformImage(Avl.Image, Avl.Matrix, bool, Avl.InterpolationMethod, Avl.Image) |
Transforms an image by the provided transformation matrix.
|
| TransformLine3D(Avl.Line3D, Avl.Matrix, bool, Avl.Line3D) |
Applies a general transformation expressed by a matrix to a 3D line.
|
| TransformPlane(Avl.Plane3D, Avl.Matrix, bool, Avl.Plane3D) |
Applies a general transformation expressed by a matrix to a plane.
|
| TransformPoint3DArray(List<Avl.Point3D>, Avl.Matrix, bool, List<Avl.Point3D>) |
Applies a general transformation expressed by a matrix to an array of 3D points.
|
| TransformPoint3DGrid(Avl.Point3DGrid, Avl.Matrix, bool, Avl.Point3DGrid) |
Applies a general transformation expressed by a matrix to a grid of 3D points.
|
| TransformPoint3D(Avl.Point3D, Avl.Matrix, bool, Avl.Point3D) |
Applies a general transformation expressed by a matrix to a 3D point.
|
| TransformSegment3D(Avl.Segment3D, Avl.Matrix, bool, Avl.Segment3D) |
Applies a general transformation expressed by a matrix to a 3D segment.
|
| TransformVector3D(Avl.Vector3D, Avl.Matrix, bool, Avl.Vector3D) |
Applies a general transformation expressed by a matrix to a 3D vector.
|
| TranslateArc(Avl.Arc2D, Avl.Vector2D, bool, Avl.Arc2D) |
Translates an arc by a vector.
|
| TranslateBox3D(Avl.Box3D, Avl.Vector3D, bool, Avl.Box3D) |
Shifts a box in 3D by a vector.
|
| TranslateBox(Avl.Box, int, int, bool, Avl.Box) |
Shifts a box by a discreet vector.
|
| TranslateCircle3D(Avl.Circle3D, Avl.Vector3D, bool, Avl.Circle3D) |
Shifts a circle in 3D by a vector.
|
| TranslateCircle(Avl.Circle2D, Avl.Vector2D, bool, Avl.Circle2D) |
Translates a circle by a vector.
|
| TranslateCoordinateSystem(Avl.CoordinateSystem2D, Avl.Vector2D, bool, Avl.CoordinateSystem2D) |
Translates a coordinate system by a vector.
|
| TranslateImage(Avl.Image, Avl.Pixel, int, int, bool, Avl.Image) |
Translates an image by a vector, without changing its dimensions.
|
| TranslateLine3D(Avl.Line3D, Avl.Vector3D, bool, Avl.Line3D) |
Shifts a line in 3D by a vector.
|
| TranslateLine(Avl.Line2D, Avl.Vector2D, bool, Avl.TranslateAlignment, Avl.Line2D) |
Translates a line by a vector.
|
| TranslateLocation(Avl.Location, int, int, bool, Avl.Location) |
Shifts a Location by a given number of pixels along each axis.
|
| TranslatePathArray(List<Avl.Path>, Avl.Vector2D, bool, List<Avl.Path>) |
Translates an array of paths by a vector.
|
| TranslatePath(Avl.Path, Avl.Vector2D, bool, Avl.Path) |
Translates a path by a vector.
|
| TranslatePixels(Avl.Image, Avl.Image, Optional<Avl.Region>, Avl.InterpolationMethod, Avl.Image) |
Moves the pixels of the input image by the vectors specified with inVectorImage.
|
| TranslatePlane(Avl.Plane3D, Avl.Vector3D, bool, Avl.Plane3D) |
Shifts a plane in 3D by a vector.
|
| TranslatePoint3DArray(List<Avl.Point3D>, Avl.Vector3D, bool, List<Avl.Point3D>) |
Translates an array of points by a vector.
|
| TranslatePoint3DGrid(Avl.Point3DGrid, Avl.Vector3D, bool, Avl.Point3DGrid) |
Translates a grid of points by a vector.
|
| TranslatePoint3D_Toward(Avl.Point3D, Avl.Point3D, float, bool, Avl.Point3D) |
Translates a point in 3D towards another point in 3D by a specified distance.
|
| TranslatePoint3D(Avl.Point3D, Avl.Vector3D, bool, Avl.Point3D) |
Translates a point by a vector.
|
| TranslatePointArray(List<Avl.Point2D>, Avl.Vector2D, bool, List<Avl.Point2D>) |
Translates an array of points by a vector.
|
| TranslatePoint_Toward(Avl.Point2D, Avl.Point2D, float, bool, Avl.Point2D) |
Translates a point towards another point by a specified distance.
|
| TranslatePoint(Avl.Point2D, Avl.Vector2D, bool, Avl.Point2D) |
Translates a point by a vector.
|
| TranslateRectangle(Avl.Rectangle2D, Avl.Vector2D, bool, Avl.Rectangle2D) |
Translates a rectangle by a vector.
|
| TranslateRegion(Avl.Region, int, int, bool, Optional<int>, Optional<int>, Avl.Region) |
Translates a region by a given number of pixels along each axis.
|
| TranslateSegment3D(Avl.Segment3D, Avl.Vector3D, bool, Avl.Segment3D) |
Shifts a segment in 3D by a vector.
|
| TranslateSegment(Avl.Segment2D, Avl.Vector2D, bool, Avl.TranslateAlignment, Avl.Segment2D) |
Translates a segment by a vector.
|
| TranslateSurface(Avl.Surface, Avl.Vector3D, bool, Avl.Surface) |
Translates a surface by a vector.
|
| translate(Avl.Point2D, Avl.Vector2D) | |
| translate(Avl.Segment2D, Avl.Vector2D) | |
| translate(Avl.Point2D, float, float) | |
| TransposeImage(Avl.Image, Avl.Image) |
Flips and rotates an image so that columns are exchanged with rows.
|
| TransposePath(Avl.Path, Avl.Path) |
Flips and rotates a path so that x-coordinates are exchanged with y-coordinates.
|
| TransposeRegion(Avl.Region, Avl.Region) |
Flips and rotates a region so that x-coordinates are exchanged with y-coordinates.
|
| TrimImageToRegion(Avl.Image, Avl.Region, Avl.Pixel, Avl.Image) |
Trims an image to the area of the specified region.
|
| TrimLine3D(Avl.Line3D, Avl.Box3D, Conditional<Avl.Segment3D>) |
Creates a segment contained in a box in 3D from a line in 3D.
|
| TrimLineToRectangle(Avl.Line2D, Avl.Rectangle2D, Conditional<Avl.Segment2D>) |
Creates a segment contained in a rectangle from a line.
|
| TrimLine(Avl.Line2D, Avl.Box, Conditional<Avl.Segment2D>) |
Creates a segment contained in a box from a line.
|
| TrimPathArrayToRectangle(List<Avl.Path>, Avl.Rectangle2D, Avl.TrimPathMethod, List<Avl.Path>) |
Creates an array of paths contained in a rectangle from another array of paths.
|
| TrimPathArray(List<Avl.Path>, Avl.Box, Avl.TrimPathMethod, List<Avl.Path>) |
Creates an array of paths contained in a box from another array of paths.
|
| TrimPathToRectangle(Avl.Path, Avl.Rectangle2D, Avl.TrimPathMethod, Avl.Path) |
Creates a path contained in a rectangle from another path.
|
| TrimPath(Avl.Path, Avl.Box, Avl.TrimPathMethod, Avl.Path) |
Creates a path contained in a box from another path.
|
| TrimPoint3DArray(List<Avl.Point3D>, Avl.Box3D, List<Avl.Point3D>) |
Removes points not contained in a box in 3D from an array.
|
| TrimPointArrayToRegion(List<Avl.Point2D>, Avl.Region, List<Avl.Point2D>) |
Trims an array of points to a region.
|
| TrimPointArray(List<Avl.Point2D>, Avl.Box, List<Avl.Point2D>) |
Removes points not contained in a box from an array.
|
| TrimRegionToPolygon(Avl.Region, Avl.Path, Avl.Region) |
Removes region elements lying beyond the specified polygon.
|
| TrimRegionToRectangle(Avl.Region, Avl.Rectangle2D, Optional<Avl.CoordinateSystem2D>, Avl.Region, Optional<Avl.Rectangle2D>) |
Limits a region to a rectangular area.
|
| TrimSegment3D(Avl.Segment3D, Avl.Box3D, Conditional<Avl.Segment3D>) |
Creates a segment contained in a box in 3D from another segment in 3D.
|
| TrimSegmentToCircle(Avl.Segment2D, Avl.Circle2D, Conditional<Avl.Segment2D>) |
Creates a segment contained in a circle from another segment.
|
| TrimSegmentToPolygon(Avl.Path, Avl.Segment2D, List<Avl.Segment2D>) |
Finds all subsegments that are inside a given polygon.
|
| TrimSegmentToRectangle(Avl.Segment2D, Avl.Rectangle2D, Conditional<Avl.Segment2D>) |
Creates a segment contained in a rectangle from another segment.
|
| TrimSegment(Avl.Segment2D, Avl.Box, Conditional<Avl.Segment2D>) |
Creates a segment contained in a box from another segment.
|
| UncropImage(Avl.Image, Avl.Box, int, int, Avl.Image) |
Inverse of CropImage.
|
| UncropProfile(Avl.Profile, int, int, Avl.Profile) |
Extends the profile by adding zeros at the beginning and at the end.
|
| UncropRegion(Avl.Region, Avl.Box, int, int, Avl.Region) |
Inverse of CropRegion.
|
| UnmapPoint(Avl.SpatialMap, Avl.Point2D, Conditional<Avl.Point2D>) |
Computes locations of image point on the source image from image point location
on remapped image.
|
| ValueLimitsToValueLimits_f64(Avl.ValueLimits, Avl.ValueLimits_f64) |
Converts value limits of different types.
|
| ValueLimits_f64ToValueLimits(Avl.ValueLimits_f64, Avl.ValueLimits) |
Converts value limits of different types.
|
| Vector2DToVector3D_AxesPlane(Avl.Vector2D, Avl.PlaneType, float, Avl.Vector3D, Optional<Avl.Plane3D>) |
Projects a 2D vector onto a plane defined by 3D coordinate axes.
|
| Vector2DToVector3D(Avl.Vector2D, Avl.Vector3D) |
Converts a vector in 2D to a vector in 3D.
|
| Vector3DAzimuth(Avl.Vector3D, float) |
Computes the angle between a 3D vector's projection to the XY plane and the
X axis measured toward Y axis, as an angle in the range from 0 to 360.
|
| Vector3DElevation(Avl.Vector3D, float) |
Computes the angle between a 3D vector's projection to the XY plane and itself
measured toward Z axis, as an angle in the range from -90 to 90.
|
| Vector3DLength(Avl.Vector3D, float) |
Computes the length of a 3D vector.
|
| Vector3DToVector2D_AxesPlane(Avl.Vector3D, Avl.PlaneType, Avl.Vector2D, Optional<Avl.Plane3D>) |
Projects a 3D vector onto a plane defined by coordinate axes.
|
| Vector3DToVector2D(Avl.Vector3D, Avl.Vector2D) |
Converts a vector in 3D to a vector in 2D by ignoring its Z coordinates.
|
| VectorBetweenPoints3D(Avl.Point3D, Avl.Point3D, Avl.Vector3D) |
Computes a vector representing distance from one point in 3D to another.
|
| VectorBetweenPoints(Avl.Point2D, Avl.Point2D, Avl.Vector2D) |
Computes a vector representing distance from one point to another.
|
| VectorDirection(Avl.Vector2D, float) |
Computes the direction angle of a vector as an angle in range the from 0 to
360.
|
| VectorLength(Avl.Vector2D, float) |
Computes the length of a vector.
|
| Vectors3DMedian(List<Avl.Vector3D>, Optional<List<float>>, int, Avl.Vector3D, Optional<float>, Diagnostic<List<Avl.Vector3D>>) |
Computes the geometric median of the input vectors.
|
| VectorsMedian(List<Avl.Vector2D>, Optional<List<float>>, int, Avl.Vector2D, Optional<float>, Diagnostic<List<Avl.Vector2D>>) |
Computes the geometric median of the input vectors.
|
| VerifyProjectID(int, bool, bool) |
Verifies a project ID.
|
| VerifyRegion(Avl.Region) |
Checks if the point-runs of the input region are correctly arranged (sorted,
not overlapping etc.).
|
| VisualizeHeatmap_Old(Avl.ColorizeImageState, Avl.Image, Avl.Image, Avl.ColorPalette, int, Optional<int>, Optional<int>, Optional<int>, bool, Avl.Image, Diagnostic<Avl.Image>) |
Colorizes a heat-map and blends it with a background image.
|
| VisualizeHeatmap(Optional<Avl.Image>, Avl.Heatmap, Avl.ColorPalette, Optional<float>, bool, bool, Avl.Image, Diagnostic<Avl.Image>) |
Colorizes heat-map and blends it with background image.
|
| VisualizeSurface(Avl.Surface, Avl.ColorPalette, Avl.Image, float, float) |
Colorizes surface to show it as 2D image.
|
| VoxelizePoint3DGrid(Avl.Point3DGrid, Optional<Avl.Region>, float, Avl.Point3DGrid) |
Keeps one point from each occupied voxel of a given size. Value of all remaining
grid points is set to invalid.
|
| WebHMIColorToString(string, string) |
Converts a WebHMI color to HTML color notation.
|
| WebSocket_Close(int) |
Closes a WebSocket connection.
|
| WebSocket_Connect(Avl.WebSocketConnectionState, string, Optional<int>, Optional<int>, bool, Optional<string>, Conditional<int>) |
Connects to a remote server using WebSocket protocol.
|
| WebSocket_ReadBuffer(int, Optional<int>, Avl.ByteBuffer) |
Receives a byte buffer from a connected WebSocket.
|
| WebSocket_ReadText(int, Optional<int>, string) |
Receives a string from a connected WebSocket.
|
| WebSocket_WriteBuffer(int, Avl.ByteBuffer) |
Outputs a byte buffer through a connected WebSocket.
|
| WebSocket_WriteText(int, string) |
Outputs a string through a connected WebSocket.
|
| WKT_LoadLineString(string, Avl.Path) |
Loads path from WKT text format.
|
| WKT_LoadMultiLineString(string, List<Avl.Path>) |
Loads multiple paths from WKT text format.
|
| WKT_LoadMultiPoint(string, List<Avl.Point2D>) |
Loads multiple points from WKT text format.
|
| WKT_LoadMultiPolygon_AsRegion(string, int, int, List<Avl.Region>) |
Loads multiple polygons from WKT text format as region.
|
| WKT_LoadMultiPolygon(string, List<Avl.Path>, List<List<Avl.Path>>) |
Loads multiple polygons from WKT text format.
|
| WKT_LoadPoint(string, Avl.Point2D) |
Loads point from WKT text format.
|
| WKT_LoadPolygon_AsRegion(string, int, int, Avl.Region) |
Loads polygon from WKT text format as region.
|
| WKT_LoadPolygon(string, Avl.Path, List<Avl.Path>) |
Loads polygon from WKT text format.
|
| WorldPlaneEdgesToImage(List<Avl.Edge1D>, Avl.RectificationTransform, List<Avl.Edge1D>) |
Finds the image coordinates of world plane Edges.
|
| WorldPlaneEdgeToImage(Avl.Edge1D, Avl.RectificationTransform, Avl.Edge1D) |
Finds the image coordinates of world plane Edge.
|
| WorldPlaneGapsToImage(List<Avl.Gap1D>, Avl.RectificationTransform, List<Avl.Gap1D>) |
Finds the image coordinates of world plane Gaps.
|
| WorldPlaneGapToImage(Avl.Gap1D, Avl.RectificationTransform, Avl.Gap1D) |
Finds the image coordinates of world plane Gap.
|
| WorldPlanePathsToImage(List<Avl.Path>, Avl.RectificationTransform, List<Avl.Path>) |
Finds the image coordinates of world plane Paths.
|
| WorldPlanePathToImage(Avl.Path, Avl.RectificationTransform, Avl.Path) |
Finds the image coordinates of world plane Path.
|
| WorldPlanePointsToImage(List<Avl.Point2D>, Avl.RectificationTransform, List<Avl.Point2D>) |
Finds the image coordinates of world plane Points.
|
| WorldPlanePointToImage(Avl.Point2D, Avl.RectificationTransform, Avl.Point2D) |
Finds the image coordinates of world plane Point.
|
| WorldPlaneRidgesToImage(List<Avl.Ridge1D>, Avl.RectificationTransform, List<Avl.Ridge1D>) |
Finds the image coordinates of world plane Ridges.
|
| WorldPlaneRidgeToImage(Avl.Ridge1D, Avl.RectificationTransform, Avl.Ridge1D) |
Finds the image coordinates of world plane Ridge.
|
| WorldPlaneSegmentsToImage(List<Avl.Segment2D>, Avl.RectificationTransform, List<Avl.Segment2D>) |
Finds the image coordinates of world plane Segments.
|
| WorldPlaneSegmentToImage(Avl.Segment2D, Avl.RectificationTransform, Avl.Segment2D) |
Finds the image coordinates of world plane Segment.
|
| WorldPlaneStripesToImage(List<Avl.Stripe1D>, Avl.RectificationTransform, List<Avl.Stripe1D>) |
Finds the image coordinates of world plane Stripes.
|
| WorldPlaneStripeToImage(Avl.Stripe1D, Avl.RectificationTransform, Avl.Stripe1D) |
Finds the image coordinates of world plane Stripe.
|
| WriteLog(string, Avl.LogsLevel) |
Write log message with selected log level.
|
| WriteVideoStream(Avl.OutputVideoStream, Avl.Image) |
Writes an image to a previously opened video stream.
|
| XyzToRgb(Avl.Image, Avl.Image) |
Converts color space from XYZ to Red-Green-Blue.
|
| YCoCgRToRgb(Avl.Image, Avl.Image) |
Converts color space from pseudointensitY-Orange-Green-with-Reversibility into
Red-Green-Blue.
|
| YCoCgToRgb(Avl.Image, Avl.Image) |
Converts color space from pseudointensitY-Orange-Green into Red-Green-Blue.
|
| Yuv442ToRgb(Avl.Image, Avl.Image) |
Converts a YUV-encoded image into RGB color space.
|
| YuvToRgb(Avl.Image, Avl.Image) |
Converts color space from YUV into Red-Green-Blue.
|
