Examples
+a = imread("m1.jpeg"); +b = imread("m2.jpeg"); +c = imread("m3.jpeg"); +num = 3; +maxBits= 6; +excludeRange = 4; +cut = %t; +[x, y, z] = align(maxBits, excludeRange, cut, num, a, b, c); |  |  |
This function aligns the set of input images for HDR image creation.
[out1, out2, out3] = align(maxBits, excludeRange, cut, num, srcImg_1, srcImg_2, srcImg_3) +[out1, out2, out3, out4] = align(maxBits, excludeRange, cut, num, srcImg1, srcImg_2, srcImg_3, srcImg_4) +[out1, out2, out3, out4, out5] = align(maxBits, excludeRange, cut, num, srcImg_1, srcImg_2, srcImg_3, srcImg_4, srcImg_5)
Logarithm to the base 2 of maximal shift in each dimension. Values of 5 and 6 are usually good enough (31 and 63 pixels shift respectively). Value should not exceed 6. It is of Double type.
Range for exclusion bitmap that is constructed to suppress noise around the median value. It is of Double type.
If true, cuts images. Otherwise fills the new regions with zeros. It is of Boolean type.
Number of images given as input source images(3 - 5). It is of double type.
Hypermat of image_i.
This function uses AlignMTB algorithm which converts images to median threshold bitmaps (1 for pixels brighter than median luminance and 0 otherwise) and than aligns the resulting bitmaps using bit operations.
+a = imread("m1.jpeg"); +b = imread("m2.jpeg"); +c = imread("m3.jpeg"); +num = 3; +maxBits= 6; +excludeRange = 4; +cut = %t; +[x, y, z] = align(maxBits, excludeRange, cut, num, a, b, c); | | |
a = imread("t1.jpeg"); +b = imread("t2.jpeg"); +c = imread("t3.jpeg"); +d = imread("t4.jpeg"); +num = 4; +maxBits= 6; +excludeRange = 4; +cut = %f; +[x, y, z, p] = align(maxBits, excludeRange, cut, num, a, b, c, d); | | |
// error cause maxBits value is greater than 6 +a = imread("m1.jpeg"); +b = imread("m2.jpeg"); +c = imread("m3.jpeg"); +d = imread("m4.jpeg"); +num = 4; +maxBits= 7; +excludeRange = 4; +cut = %t; +[x, y, z, p] = align(maxBits, excludeRange, cut, num, a, b, c, d); | | |
a = imread("m1.jpeg"); +b = imread("m2.jpeg"); +c = imread("m3.jpeg"); +d = imread("m4.jpeg"); +e = imread("m5.jpeg"); +num = 5; +maxBits= 6; +excludeRange = 4; +cut = %t; +[x, y, z, p, q] = align(maxBits, excludeRange, cut, num, a, b, c, d, e); | | |
// cut is set false here (if true cuts images, otherwise fills the new regions with zeros. ) +a = imread("t1.jpeg"); +b = imread("t2.jpeg"); +c = imread("t3.jpeg"); +num = 3; +maxBits= 1; +excludeRange = 4; +cut = %t; +[x, y, z] = align(maxBits, excludeRange, cut, num, a, b, c); | | |
This function is used to apply affine or TPS transformation to image.
[ tImg] = applyTransformer(srcImg1, srcImg2, typeOfMethod, hessianThreshold, rpTPS, sfAffine)
It is the first input image.
It is the second input image, which is also the target image.
It is used as a flag to pick a certain type of transformation. Use value '1' for 'Affine Transformation' and '2' for 'Thin Plate Spline Shape Transformation'. It is of double type.
It is the threshold value for Hessian keypoint detector in SURF(Speeded-Up Robust Features). It is of double type.
It is used to set the regularization parameter for relaxing the exact interpolation requirements of the TPS algorithm. It is of double type.
It is used to set the full-affine condition for Affine Transformation. If true, the function finds as optimal transformation with no additional restrictions(6 degrees of freedom). Otherwise, the class of transformations to choose from is limited to combination of translation, rotation & uniform scaling(5 degrees of freedom).
The transformed image of the target(srcImg2). It is of hypermat type.
This function is used to perform shape transformation, the user gets to choose and apply the type of transformation she/he wishes to perform.
+affine transformation +a = imread("bryan.jpeg"); +b = imread("p1.jpg"); +typeOfMethod=1 +hessianThreshold=5000; +rpTPS=25000; +sfAffine=%f; +img=applyTransformer(a,b,typeOfMethod,hessianThreshold, rpTPS, | | |
a= imread("lena.jpeg"); +b= imread("bryan.jpeg"); +typeOfMethod=1 +hessianThreshold=5000; +rpTPS=2000; +sfAffine=%t; +img=applyTransformer(a,b,typeOfMethod,hessianThreshold, rpTPS,sfAffine); | | |
TPS shape transformation +a = imread("photo.jpg"); +b= imread("photo1.jpg"); +typeOfMethod=2 +hessianThreshold=5000; +rpTPS=800; +sfAffine=%t; +img=applyTransformer(a,b,typeOfMethod,hessianThreshold, rpTPS,sfAffine); | | |
This function performs 2*2 and 3*3 nonlinear filtering using a lookup table.
[out] = bwLookUp(image,lut)
The input is a grayscale image. If the image is not binary, it is converted to one.
The lut is a 1*16 double vector [2*2 filtering], or a [1*512] double vector [3*3 filtering].
The output image is the same size as image, same data type as lut.
The function performs a 2-by-2 or 3-by-3 nonlinear neighborhood filtering operation on a grayscale image and returns the results in the output image. The neighborhood processing determines an integer index value used to access values in a lookup table 'lut'. The fetched lut value becomes the pixel value in the output image at the targeted position.
+// a simple example +a = imread("lena.jpeg", 0); +lut = [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ]; +b = bwLookUp(a,lut); | | |
This function calculates the contour area.
[out] = contourArea(inputArrayContour, booloriented)
The input vector of 2D points.
The oriented area flag. If it is true, the function returns a signed area value, depending on the contour orientation (clockwise or counter-clockwise). Using this feature you can determine the orientation of a contour by taking the sign of an area.
The output is the calculated area.
It computes the contour area. Also, the function will most certainly give a wrong results for contours with self-intersections.
+// a simple example +inputArrayContour = [0 0; 10 0; 10 10; 5 4S]; +booloriented = %t; +b = contourArea(inputArrayContour, booloriented); | | |
This function forms a border around the input image.
[new_image] = copyMakeBorder(image, top, bottom, left, right, borderType, value)
The source image.
No. of pixels in this direction from the source image rectangle to extrapolate.
No. of pixels in this direction from the source image rectangle to extrapolate.
No. of pixels in this direction from the source image rectangle to extrapolate.
No. of pixels in this direction from the source image rectangle to extrapolate.
Stating the border type.
Border value if borderType==BORDER_CONSTANT.
The output image with specified borders.
This function forms a border around the input image. The areas to the left, to the right, above and below the copied source image are filled with the extrapolated pixels.
+// a simple example +a = imread("lena.jpeg"); +top=1; +bottom=1; +left=1; +right=1; +b = copyMakeBorder(a, top, bottom, left, right, "BORDER_CONSTANT", 1); | | |
This function is used for computing BRIEF descriptors using Star keypoints.
[ a ] = detectBRIEFDescriptors(srcImg) +[ a ] = detectVRIEFDescriptors(srcImg, maxSize, responseThreshold, lineThresholdProjected, lineThresholdBinarized, suppressNonmaxSize, bytes, use_orientation )
Hyper of input image
Choose the number of filters to be applied, the parameter value set the maximum size.
To eliminate weak corners.
Harris of responses.
Harris of sizes.
Window size (n-by-n) to apply the non-maximal suppression.
legth of the descriptor in bytes, valid values are: 16, 32 (default) or 64.
sample patterns using keypoints orientation, disabled by default.
It is a struct consisting of 'Type'(Type of Feature) , 'Features'(descriptors) , 'NumBits', 'NumFeatures', 'KeyPoints', 'keypointsCount'.
For extracting keypoints(StarDetector) and computing descriptors. BRIEF which gives the shortcut to find binary descriptors with less memory, faster matching, still higher recognition rate.
+// with default values +[ a ] = imread("b1.jpeg"); +[ b ] = imread("b2.jpeg"); +stacksize("max); +[ c ] = detectBRIEFDescriptors(a); +[ d ] = detectBRIEFDescriptors(b); +[ e f ] = matchFeatures(c.Features, d.Features); +out = drawMatch(a, b, c.KeyPoints, d.KeyPoints, e, f); | | |
// user assigned values +[ a ] = imread("b1.jpeg"); +[ b ] = imread("b2.jpeg"); +stacksize("max); +[ c ] = detectBRIEFDescriptors(a, 45, 30, 10, 8, 5, 32, %f); +[ d ] = detectBRIEFDEscriptors(b, 45, 30, 10, 8, 5, 32, %f); +[ e f ] = matchFeatures(c.Features, d.Features); +out = drawMatch(a, b, c.KeyPoints, d.KeyPoints, e, f); | | |
This function is used for computing DAISY descriptors using Star keypoints.
[ a ] = detectDAISYDescriptors(srcImg) +[ a ] = detectDAISYDescriptors(srcImg, maxSize, responseThreshold, lineThresholdProjected, lineThresholdBinarized, suppressNonmaxSize, radius, q_radius, q_theta, q_hist, norm, interpolation, use_orientation) +[ a ] = detectDAISYDescriptors(srcImg, maxSize, responseThreshold, lineThresholdProjected, lineThresholdBinarized, suppressNonmaxSize, radius, q_radius, q_theta, q_hist, norm, homography, interpolation, use_orientation)
Hyper of input image
Choose the number of filters to be applied, the parameter value set the maximum size.
To eliminate weak corners.
Harris of responses.
Harris of sizes.
Window size (n-by-n) to apply the non-maximal suppression.
radius of the descriptor at the initial scale.
amount of radial range division quantity.
amount of angular range division quantity.
amount of gradient orientations range division quantity.
choose descriptors normalization type, where DAISY::NRM_NONE will not do any normalization (default), DAISY::NRM_PARTIAL mean that histograms are normalized independently for L2 norm equal to 1.0, DAISY::NRM_FULL mean that descriptors are normalized for L2 norm equal to 1.0, DAISY::NRM_SIFT mean that descriptors are normalized for L2 norm equal to 1.0 but no individual one is bigger than 0.154 as in SIFT
optional 3x3 homography matrix used to warp the grid of daisy but sampling keypoints remains unwarped on image.
switch to disable interpolation for speed improvement at minor quality loss.
sample patterns using keypoints orientation, disabled by default.
It is a struct consisting of 'Type'(Type of Feature) , 'Features'(descriptors) , 'NumBits', 'NumFeatures', 'KeyPoints', 'keypointsCount'.
For extracting keypoints(using StarDetector) and computing descriptors(DAISY).
+// with default values +[ a ] = imread("b1.jpeg"); +[ b ] = imread("b2.jpeg"); +stacksize('max') +[ c ] = detectDAISYDescriptors(a); +[ d ] = detectDAISYDescriptors(b); +[ e f ] = matchFeatures(c.Features, d.Features); +out = drawMatch(a, b, c.KeyPoints, d.KeyPoints, e, f); | | |
// user assigned values +[ a ] = imread("b1.jpeg"); +[ b ] = imread("b2.jpeg"); +stacksize('max') +[ c ] = detectDAISYDescriptors(a, 45, 30, 10, 8, 5, 15, 3, 8, 8, 100, %t, %f); +[ d ] = detectDAISYDEscriptors(b, 45, 30, 10, 8, 5, 15, 3, 8, 8, 100, %t, %f); +[ e f ] = matchFeatures(c.Features, d.Features); +out = drawMatch(a, b, c.KeyPoints, d.KeyPoints, e, f); | | |
This function is used for computing the LATCH descriptors using Star keypoints.
[ a ] = detectLATCHDescriptors(srcImg) +[ a ] = detectLATCHDescriptors(srcImg, maxSize, responseThreshold, lineThresholdProjected, lineThresholdBinarized, suppressNonmaxSize, bytes, rotationInvariance, half_ssd_size)
Hyper of input image
Choose the number of filters to be applied, the parameter value set the maximum size.
To eliminate weak corners.
Harris of responses.
Harris of sizes.
Window size (n-by-n) to apply the non-maximal suppression.
It is the size of the descriptor - can be 64, 32, 16, 8, 4, 2 or 1.
whether or not the descriptor should compansate for orientation changes.
the size of half of the mini-patches size. For example, if we would like to compare triplets of patches of size 7x7x then the half_ssd_size should be (7-1)/2 = 3.
It is a struct consisting of 'Type'(Type of Feature) , 'Features'(descriptors) , 'NumBits', 'NumFeatures', 'KeyPoints', 'keypointsCount'.
For extracting keypoints(using StarDetectors) and computing descriptors(LATCH).
+// with default values +[ a ] = imread("b1.jpeg"); +[ b ] = imread("b2.jpeg"); +stacksize('max') +[ c ] = detectLATCHdescriptors(a); +[ d ] = detectLATCHDescriptors(b); +[ e f ] = matchFeatures(c.Features, d.Features); +out = drawMatch(a, b, c.KeyPoints, d.KeyPoints, e, f); | | |
// user assigned values +[ a ] = imread("b1.jpeg"); +[ b ] = imread("b2.jpeg"); +stacksize('max') +[ c ] = detectLATCHdescriptors(a, 45, 30, 10, 8, 5, 32, %t, 3); +[ d ] = detectLATCHDEscriptors(b, 45, 30, 10, 8, 5, 32, %t, 3); +[ e f ] = matchFeatures(c.Features, d.Features); +out = drawMatch(a, b, c.KeyPoints, d.KeyPoints, e, f); | | |
This function is used to find scale-invariant features.
[ a ] = detectSIFTFeatures(srcImg) +[ a ] = detectSIFTFeatures(srcImg, features, nOctaveLayers, contrastThreshold, edgeThreshold, sigma)
Hyper of input image.
The number of best features to retain. The features are ranked by their scores (measured in SIFT algorithm as the local contrast). If valued as 0, uses all detected keypoints.
The number of layers in each octave. 3 is the value used in D. Lowe paper. The number of octaves is computed automatically from the image resolution.
The contrast threshold used to filter out weak features in semi-uniform (low-contrast) regions. The larger the threshold, the less features are produced by the detector.
The threshold used to filter out edge-like features. Note that the its meaning is different from the contrastThreshold, i.e. the larger the edgeThreshold, the less features are filtered out (more features are retained).
The sigma of the Gaussian applied to the input image at the octave #0. If your image is captured with a weak camera with soft lenses, you might want to reduce the number.
It is a struct consisting of 'Type'(Type of Feature) , 'Features'(descriptors) , 'NumBits', 'NumFeatures', 'KeyPoints', 'keypointsCount'.
For extracting keypoints and computing descriptors using the Scale Invariant Feature Transform. RGB images are converted to Grayscale images before processing.
+// with default values +a = imread("photo1.jpeg"); +b = imread("photo2.jpeg"); +stacksize("max"); +c = detectSIFTFeatures(a); +d = detectSIFTFeatures(b); +[ e f ] = matchFeatures(c.Features, d.Features); +out = drawMatch(a, b, c.KeyPoints, d.KeyPoints, e, f); | | |
// user assigned values +a = imread("photo1.jpeg"); +b = imread("photo2.jpeg"); +stacksize("max"); +c = detectSIFTFeatures(a, 0, 3, 0.05, 11, 1.6); +d = detectSIFTFeatures(b, 0, 3, 0.05, 11, 1.6); +[ e f ] = matchFeatures(c.Features, d.Features); +out = drawMatch(a, b, c.KeyPoints, d.KeyPoints, e, f); | | |
This function computes the shape-distance between two images.
[ dist ] = distanceExtractor(srcImg1, srcImg2, typeOfMethod); // Hausdorrf distance +[ dist ] = distanceExtractor(srcImg1, srcImg2, typeOfMethod, nAngularBins, innerRadius, nRadialBins, outerRadius, iterations); // Shape Context
It is the first input image.
It is the second input image.
It is used as a flag to pick a certain type of Shape Distance calculation technique. Use '1' for 'Shape Context' and '2' for 'Hausdorrf'.
Establish the number of angular bins for the Shape Context Descriptor used in the shape matching pipeline.
Establish the number of radial bins for the Shape Context Descriptor used in the shape matching pipeline.
Set the inner radius of the shape context descriptor.
Set the outer radius of the shape context descriptor.
It is the calculated distance. It is of double type.
This function is used to compute the shape distance between two shapes defined by its contours.
+// Hausdorff distance extractor +a = imread("bnwhite.jpg"); +b = imread("bryan.jpeg"); +typeOfMethod=2;//2 is for hausdorff +c=distanceExtractor(a,b,typeOfMethod);orff | | |
// Shape Context Distance extractor +a = imread("photo.jpg"); +b = imread("photo1.jpg"); +typeOfMethod=1; //1 for ShapeContext +nAngularBins=12; +nRadialBins=4; +innerRadius=0.2; +outerRadius=2; +iterations=3; +ndummies = 25; +defaultCost = 0.2; +rpTps =0 ; +dist=distanceExtractor(a,b,typeOfMethod,nAngularBins,nRadialBins,innerRadius,outerRadius,iterations,ndummies,dC,rpTps); | | |
Incorrect usage +a=4; (not hypermat) +b=88; (not hypermat) +typeOfMethod=1; //1 for ShapeContext +nAngularBins=12; +nRadialBins=4; +innerRadius=2; +outerRadius=0.2; +iterations=300; +ndummies = 25; +defaultCost = 0.2; +rpTps =0 ; +dist=distanceExtractor(a,b,typeOfMethod,nAngularBins,nRadialBins,innerRadius,outerRadius,iterations,ndummies,dC,rpTps); | | |
This function fills a convex polygon.
[out] = fillConvexPoly(img, pstData, npts, r_value, g_value, b_value, linetype, shift)
The input source image.
The vector of polygon vertices.
The number of polygon vertices.
The red value of RGB color for the polygon.
The green value of RGB color for the polygon.
The blue value of RGB color for the polygon.
This is the type of the polygon boundaries. It has only 3 valid types: 4, 8 and 16(CV_AA). Passing any other value as lineType is not legal.
This is the number of fractional bits in the vertex coordinates.
The function fillConvexPoly draws a filled convex polygon. It can fill not only convex polygons but any monotonic polygon without self-intersections, that is, a polygon whose contour intersects every horizontal line (scan line) twice at the most (though, its top-most and/or the bottom edge could be horizontal).
+// a simple example +a = imread("lena.jpeg"); +b = [ 0 10; 10 0; -10 0 ]; +c = fillConvexPoly(a, b, 3, 1, 1, 1, 8, 0); | | |
This function creates a Gabor filter.
[outputImg] = gabor(wavelength,orientation)
It is the wavelength of sinusoid, specified as a numeric scalar or vector, in pixels/cycle.
It is the orientation of filter in degrees, specified as a numeric scalar in the range [0 180], where the orientation is defined as the normal direction to the sinusoidal plane wave.
The Gabor filter.
It creates a Gabor filter with the specified wavelength (in pixels/cycle) and orientation (in degrees). If you specify wavelength or orientation as vectors, gabor returns an array of gabor objects, called a filter bank, that contain all the unique combinations of wavelength and orientation. For example, if wavelength is a vector of length 2 and orientation is a vector of length 3, then the output array is a vector of length 6.
+// Create an array of Gabor filters. +wavelength = 20; +orientation = 45; +a = gabor(wavelength, orientation); | | |
This function blurs the input image using a Gaussian filter.
outputImg = gaussianblur(inputImage,ksize_height,ksize_width,sigmaX,sigmaY)
The input source image.
It is the gaussian kernel height. It must be positive and odd.
It is the gaussian kernel width. It must be positive and odd.
It is the gaussian kernel standard deviation in X direction.
It is the gaussian kernel standard deviation in Y direction.
The output filtered image is of the same size and type as the input image.
The function convolves the source image with the specified Gaussian kernel.
+inputImage = imread('lena.jpg'); +outputImg = gaussianBlur(inputImage,5,5,1,1); | | |
This function computes the cost matrix.
[ costMatrix ] = histogramCostExtractor(srcImg1, srcImg2, typeOfMethod=3, hessianThreshold); // Norm based cost +[ costMatrix ] = histogramcostExtractor(srcImg1, srcImg2, typeOfMethod=1, hessianThreshold, nDummies, defaultCost); // Chi as well as EMDL1 based cost extraction +[ costMatrix ] = histogramCostExtractor(srcImg1, srcImg2, typeOfMethod=2, hessianThreshold, nDummies, defaultCost); // EMDL1 based cost extraction
It is the first input image.
It is the second input image.
It is used as a flag to pick a certain type of transformation. Use value '1' for 'Chi based cost ectraction', '2' for 'EMDL1 based cost extraction' and '3' for 'Norm based cost extraction'. It is of double type.
It is the threshold value for Hessian keypoint detector in SURF(Speeded-Up Robust Features). It is of double type.
It is used to set the regularization parameter for relaxing the exact interpolation requirements of the TPS algorithm. It is of double type.
It is the cost matrix.
This function is used to calculate the histogram based cost matrix of two images, the user gets to choose and apply the type of transformation she/he wishes to perform.
+// Chi based cost extraction +a= imread("n.jpeg"); +b= imread("n1.jpeg"); +typeOfMethod=1; +hessianThreshold=5000; +nDummies=25; +defaultCost=0.2; +c=histogramCostExtractor(a,b,typeOfMethod,hessianThreshold,nDummies,defaultCost); | | |
// EMDL1 +a = imread("n.jpeg"); +b = imread("n1.jpeg"); +typeOfMethod=2; +hessianThreshold=5000; +nDummies=25; +defaultCost=0.2; +c=histogramCostExtractor(a,b,typeOfMethod,hessianThreshold,nDummies,defaultCost); | | |
Norm based cost extraction +a = imread("n.jpeg"); +b= imread("n1.jpeg"); +typeOfMethod=3; +hessianThreshold=5000; +c=histogramCostExtractor(a,b,typeOfMethod,hessianThreshold); | | |
The function applies Gabor filter or set of filters to 2-D image.
[new_image] = imGaborFilt(image, wavelength, orientation)
The input grayscale image.
It is the wavelength of the sinusoidal carrier, specified as a numeric scalar in the range [2,Inf), in pixels/cycle.
Orientation value of filter in degrees, specified as a numeric scalar in the range [0 360], where the orientation is defined as the normal direction to the sinusoidal plane wave.
It computes the magnitude and phase response of a Gabor filter for the input grayscale image.
+// apply Single Gabor Filter to Input Image +a = imread("lena.jpeg", 0); +wavelength = 4; +orientation = 90; +b = imGaborFilt(a, wavelength, orientation) | | |
This function converts CIE 1976 L*a*b* to RGB.
[output] = lab2rgb(pstData)
The color values to convert, specified as a list of values.
The converted color values, returned as an array of the same shape as the input.
Convert CIE 1976 L*a*b* to RGB.
+// Convert a color value in L*a*b* color space to the Adobe RGB (1998) color space. +a = list(70, 5, 10); +b = lab2rgb(a); | | |
// Convert a color value in L*a*b* color space to the Adobe RGB (1998) color space. +a = list(71, 50, 10); +b = lab2rgb(a); | | |
// Convert a color value in L*a*b* color space to the Adobe RGB (1998) color space. +a = list(7.3, 5.53, 10); +b = lab2rgb(a); | | |
// Convert a color value in L*a*b* color space to the Adobe RGB (1998) color space. +a = list(70, 5, 10.6656); +b = lab2rgb(a); | | |
// Convert a color value in L*a*b* color space to the Adobe RGB (1998) color space. +a = list(70, 5.45, 10.45); +b = lab2rgb(a); | | |
// Convert a color value in L*a*b* color space to the Adobe RGB (1998) color space. +a = list(7.343, 5.34, 10); +b = lab2rgb(a); | | |
// Convert a color value in L*a*b* color space to the Adobe RGB (1998) color space. +a = list(70, 500, 1012); +b = lab2rgb(a); | | |
// Convert a color value in L*a*b* color space to the Adobe RGB (1998) color space. +a = list(701.2, 5, 10); +b = lab2rgb(a); | | |
// Convert a color value in L*a*b* color space to the Adobe RGB (1998) color space. +a = list(70, 5.545, 1.0); +b = lab2rgb(a); | | |
// Convert a color value in L*a*b* color space to the Adobe RGB (1998) color space. +a = list(23, 51, 18); +b = lab2rgb(a); | | |
This function converts L*a*b* data to uint8.
[output] = lab2uint8(pstData)
It is a list of color values.
The converted uint8 value. lab8 has the same size as lab.
Converts L*a*b* data to uint8.
+// to convert L*a*b* color values from double to uint8. +a = list(70, 5, 10); +b = lab2rgb(a); | | |
// to convert L*a*b* color values from double to uint8. +a = list(71, 5, 10); +b = lab2rgb(a); | | |
// to convert L*a*b* color values from double to uint8. +a = list(0, 5, 10); +b = lab2rgb(a); | | |
// to convert L*a*b* color values from double to uint8. +a = list(89, 50, 10); +b = lab2rgb(a); | | |
// to convert L*a*b* color values from double to uint8. +a = list(70, 5, 10.78); +b = lab2rgb(a); | | |
// to convert L*a*b* color values from double to uint8. +a = list(7, 5, 89); +b = lab2rgb(a); | | |
// to convert L*a*b* color values from double to uint8. +a = list(70.344, 5.34, 10); +b = lab2rgb(a); | | |
// to convert L*a*b* color values from double to uint8. +a = list(0, 0, 10); +b = lab2rgb(a); | | |
// to convert L*a*b* color values from double to uint8. +a = list(70.89, 5.11, 10.33); +b = lab2rgb(a); | | |
// to convert L*a*b* color values from double to uint8. +a = list(10, 5, 10); +b = lab2rgb(a); | | |
This function is used to create HDR image.
[out1, out2] = makeHDR(typeOfMethod=1, num=3, srcMat_1, srcMat_2, srcMat_3, ex_1, ex_2, ex_3, max_iter, threshold) // Robertson merging +[out1, out2] = makeHDR(typeOfMethod=2, num=3, srcMat_1, srcMat_2, srcMat_3, ex_1, ex_2, ex_3, samples, lambda, random) // Debevec merging +[out1, out2] = makeHDR(typeOfMethod=3, num=3, srcMat_1, srcMat_2, srcMat_3, ex_1, ex_2, ex_3, contrast_weight, saturation_weight, exposure_weight) // Mertens merging +[out1, out2] = makeHDR(typeOfMethod=1, num=4, srcMat_1, srcMat_2, srcMat_3, srcMat_4, ex_1, ex_2, ex_3, ex_4, max_iter, threshold) // Robertson merging +[out1, out2] = makeHDR(typeOfMethod=2, num=4, srcMat_1, srcMat_2, srcMat_3, srcMat_4, ex_1, ex_2, ex_3, ex_4, samples, lambda, random) // Debevec merging +[out1, out2] = makeHDR(typeOfMethod=3, num=4, srcMat_1, srcMat_2, srcMat_3, srcMat_4, ex_1, ex_2, ex_3, ex_4, contrast_weight, saturation_weight, exposure_weight) // Mertens merging +[out1, out2] = makeHDR(typeOfMethod=1, num=5, srcMat_1, srcMat_2, srcMat_3, srcMat_4, srcMat_5, ex_1, ex_2, ex_3, ex_4, ex_5, max_iter, threshold) // Robertson merging +[out1, out2] = makeHDR(typeOfMethod=2, num=5, srcMat_1, srcMat_2, srcMat_3, srcMat_4, srcMat_5, ex_1, ex_2, ex_3, ex_4, ex_5, samples, lambda, random) // Debevec merging +[out1, out2] = makeHDR(typeOfMethod=3, num=5, srcMat_1, srcMat_2, srcMat_3, srcMat_4, srcMat_5, ex_1, ex_2, ex_3, ex_4, ex_5, contrast_weight, saturation_weight, exposure_weight) // Mertens merging +[out1, out2] = makeHDR(typeOfMethod=1, num=6, srcMat_1, srcMat_2, srcMat_3, srcMat_4, srcMat_5, srcMat_6, ex_1, ex_2, ex_3, ex_4, ex_5, ex_6, max_iter, threshold) // Robertson merging +[out1, out2] = makeHDR(typeOfMethod=2, num=6, srcMat_1, srcMat_2, srcMat_3, srcMat_4, srcMat_5, srcMat_6, ex_1, ex_2, ex_3, ex_4, ex_5, ex_6, samples, lambda, random) // Debevec merging +[out1, out2] = makeHDR(typeOfMethod=3, num=6, srcMat_1, srcMat_2, srcMat_3, srcMat_4, srcMat_5, srcMat_6, ex_1, ex_2, ex_3, ex_4, ex_5, ex_6, contrast_weight, saturation_weight, exposure_weight) // Mertens merging
Use '1' for 'Robertson', '2' for 'Debevec', or '3' for 'Mertens'.
It is the number of images being fed as input. It is of Double type.
It is the hypermat of input source image.
It is the exposure value of the corresponding image_i. It is of double type.
(Robertson) maximal number of Gauss-Seidel solver iterations. It is of Double type.
(Robertson) target difference between results of two successive steps of the minimization. It is of Double type.
(Debevec) number of pixel locations to use. It is of Double type.
(Debevec) smoothness term weight. Greater values produce smoother results, but can alter the response. It is of Double type.
(Debevec) if true sample pixel locations are chosen at random, otherwise they form a rectangular grid. It is of Boolean type.
(Mertens) contrast measure weight. It is of Double type.
(Mertens) saturation measure weight. It is of Double type.
(Mertens) well-exposedness measure weight. It is of Double type.
HDR image
LDR image
This function takes a set of images of the same scene in different exposures which have been aligned accordingly and outputs the HDR image.
+// input of 3 images(min), using Robertson merging technique +a = imread("t1.jpeg"); +b = imread("t2.jpeg"); +c = imread("t3.jpeg"); +num = 3; +typeOfMethod = 1; +ex1 = 15; +ex2 = 2.5; +ex3 = 0.25; +maxIter = 30; +thres = 0.01; +[hdr, ldr] = makeHDR(typeOfMethod, num, a, b, c, ex1, ex2, ex3, maxIter, thres); | | |
// Use of Debevec merging technique +a = imread("m1.jpeg"); +b = imread("m2.jpeg"); +c = imread("m3.jpeg"); +d = imread("m4.jpeg"); +e = imread("m5.jpeg"); +f = imread("m6.jpeg"); +num = 6; +typeOfMethod = 2; +ex1 = 0.0167; +ex2 = 0.034; +ex3 = 0.067; +ex4 = 0.125; +ex5 = 0.25; +ex6 = 0.5; +samples = 70; +lambda = 10.0; +random = %f; +[hdr, ldr] = makeHDR(typeOfMethod, num, a, b, c, d, e, f, ex1, ex2, ex3, ex4, ex5, ex6, samples, lambda, random); | | |
// use of Robertson merging technique +a = imread("m1.jpeg"); +b = imread("m2.jpeg"); +c = imread("m3.jpeg"); +d = imread("m4.jpeg"); +e = imread("m5.jpeg"); +f = imread("m6.jpeg"); +num = 6; +typeOfMethod = 1; +ex1 = 0.0167; +ex2 = 0.034; +ex3 = 0.067; +ex4 = 0.125; +ex5 = 0.25; +ex6 = 0.5; +maxIter = 30; +thres = 0.01; +[hdr, ldr] = makeHDR(typeOfMethod, num, a, b, c, d, e, f, ex1, ex2, ex3, ex4, ex5, ex6, maxIter, thres); | | |
// alternative to creating an HDR image, resulting image is of average exposure. Faster compared to rendering a HDR image. +a = imread("m1.jpeg"); +b = imread("m2.jpeg"); +c = imread("m3.jpeg"); +d = imread("m4.jpeg"); +e = imread("m5.jpeg"); +f = imread("m6.jpeg"); +num = 6; +typeOfMethod = 3; +ex1 = 0.0167; +ex2 = 0.034; +ex3 = 0.067; +ex4 = 0.125; +ex5 = 0.25; +ex6 = 0.5; +contrastWeight = 1.0; +saturationWeight = 1.0; +exposureWeight = 0.0; +[hdr, ldr] = makeHDR(typeOfMethod, num, a, b, c, d, e, f, ex1, ex2, ex3, ex4, ex5, ex6, contrastWeight, saturationWeight, exposureWeight); | | |
a = imread("i1.jpeg"); +b = imread("i2.jpeg"); +c = imread("i3.jpeg"); +d = imread("i4.jpeg"); +num = 4; +typeOfMethod = 2; +ex1 = 0.034; +ex2 = 0.008; +ex3 = 0.0034; +ex4 = 0.00073; +samples = 70; +lambda = 10.0; +random = %f; +[hdr, ldr] = makeHDR(typeOfMethod, num, a, b, c, d, ex1, ex2, ex3, ex4, samples, lambda, random); | | |
a = imread("i1.jpeg"); +b = imread("i2.jpeg"); +c = imread("i3.jpeg"); +d = imread("i4.jpeg"); +num = 4; +typeOfMethod = 1; +ex1 = 0.034; +ex2 = 0.008; +ex3 = 0.0034; +ex4 = 0.00073; +maxIter = 30; +thres = 0.01; +[hdr, ldr] = makeHDR(typeOfMethod, num, a, b, c, d, ex1, ex2, ex3, ex4, maxIter, thres); | | |
a = imread("i1.jpeg"); +b = imread("i2.jpeg"); +c = imread("i3.jpeg"); +d = imread("i4.jpeg"); +num = 4; +typeOfMethod = 3; +ex1 = 0.034; +ex2 = 0.008; +ex3 = 0.0034; +ex4 = 0.00073; +maxIter = 30; +contrastWeight = 1.0; +saturationWeight = 1.0; +exposureWeight = 0.0; +[hdr, ldr] = makeHDR(typeOfMethod, num, a, b, c, d, ex1, ex2, ex3, ex4, contrastWeight, saturationWeight, exposureWeight); | | |
This function converts NTSC values to RGB color space.
[output] = ntsc2rgb(pstData)
It is a list of the NTSC luminance (Y) and chrominance (I and Q) color components.
It is a list that contains the red, green, and blue values equivalent to those colors.
Converts NTSC values to RGB color space.
+// Convert the grayscale image back to RGB color space. +a = imread("b1.jpeg",0) +b = ntsc2rgb(a); | | |
// Convert the grayscale image back to RGB color space. +a = imread("b2.jpeg",0) +b = ntsc2rgb(a); | | |
// Convert the grayscale image back to RGB color space. +a = imread("graf1.jpeg",0) +b = ntsc2rgb(a); | | |
// Convert the grayscale image back to RGB color space. +a = imread("graf2.jpeg",0) +b = ntsc2rgb(a); | | |
// input RGB image +a = imread("b2.jpeg") +b = ntsc2rgb(a); | | |
// input RGB image +a = imread("graf1.jpeg") +b = ntsc2rgb(a); | | |
// input RGB image +a = imread("garf2.jpeg") +b = ntsc2rgb(a); | | |
// Convert the grayscale image back to RGB color space. +a = imread("lena.jpeg",0) +b = ntsc2rgb(a); | | |
This function is used to write 3-D point cloud to PLY or PCD file.
[] = pcwrite(pointCloud, filename) +[] = pcwrite(pointCloud, filename, fileFormat, fileType)
Object for storing point cloud, specified as a pointCloud object.
File name, specified as a character vector, specify the file name with an extension incase of two input argument.(default encoding is ASCII)
The input file type must be a PLY or PCD format file.(choose between ".ply" or ".pcd")
Choose from the following encoding, PLY - 'ascii', 'binary' and PCD - 'ascii', 'binary', or 'compressed'.
Writes the point cloud object, ptCloud, to the PLY or PCD file specified by the input.
+// Write 3-D Point Cloud to PLY File +ptCloud = pcread('teapot.ply'); +pcshow(ptCloud); +pcwrite(ptCloud,'teapotOut','ply','binary'); | | |
// Write 3-D Point Cloud to PCD File +ptCloud = pcread('teapot.ply'); +pcshow(ptCloud); +pcwrite(ptCloud,'teapotOut','pcd','binary'); | | |
This function converts RGB to CIE 1976 L*a*b*.
[output] = rgb2lab(inputImage)
It is a list of color values to convert.
The converted color values, returned as a list.
Converts RGB to CIE 1976 L*a*b*.
+// to convert the RGB white value to L*a*b. +rgb2lab([1 1 1]) | | |
// to convert the RGB white value to L*a*b. +rgb2lab([.2 .3 .4]) | | |
// Read RGB image to convert +a = imread("b1.jpeg"); +b = rgb2lab(a); | | |
// Read RGB image to convert +a = imread("b2.jpeg"); +b = rgb2lab(a); | | |
// to convert the RGB white value to L*a*b. +rgb2lab([23 23 22]) | | |
// Read RGB image to convert +a = imread("lena.jpeg"); +b = rgb2lab(a); | | |
// to convert the RGB white value to L*a*b. +rgb2lab([34.2 43.3 343.4]) | | |
// Read RGB image to convert +a = imread("graf1.jpeg"); +b = rgb2lab(a); | | |
// Read RGB image to convert +a = imread("graf2.jpeg"); +b = rgb2lab(a); | | |
// Read RGB image to convert which doesnt exit +a = imread("b.jpeg"); +b = rgb2lab(a); | | |
This function is used to compute the Structural Similarity Index (SSIM) for measuring image quality.
[ssim_val] = ssim(srcImg, reference)
The input image whose quality is to be measured. Must be the same size and class as reference.
Reference image against which quality if measured.
Structural Similarity (SSIM) Index.
Computes the Structural Similarity Index (SSIM) value.
+// a simple example +a = imread("m1.jpeg"); +b = imread("m2.jpeg"); +c = ssim(a,b); | | |
This function is used for 2-D adaptive noise-removal filtering.
[outputImg] = wiener2(inputImage,filtsize,sigma)
The input image, grayscale only.
The filter size.
The additive noise (Gaussian white noise) power is assumed to be noise. if sigma = 0 then the variance is estimated from data
The output image, is of the same size and class as the input image
It lowpass-filters a grayscale image that has been degraded by constant power additive noise.
+// a simple example +a = imread("m1.jpeg"); +filtsize = 5; +sigma = 0; +c = ssim(a,b); | | |
This function converts XYZ color values to double.
[output] = xyz2double(pstData)
list of uint16 or double array that must be real and nonsparse.
list of converted values.
Converts an M-by-3 or M-by-N-by-3 array of pstData color values to double. output has the same size as XYZ.
+// check for boundary level values +a = uint16([100 32768 65535]); +b = xyz2double(c); | | |
// check for boundary level values +a = uint16([100 32768 65536]); +b = xyz2double(a); | | |
// check for lower values +a = uint16([1 3 5]); +b = xyz2double(a); | | |
// error - inpput should be M by 3 or M by N by 3 +a = uint16([100 32768]); +b = xyz2double(a); | | |
// error - inpput should be M by 3 or M by N by 3 +a = uint16([100 32 67 56]); +b = xyz2double(a); | | |
// float value input +a = uint16([0.0031 1 2]); +b = xyz2double(a); | | |
// error - inpput should be M by 3 or M by N by 3 +a = uint16([100 32 678]); +b = xyz2double(a); | | |
// error - inpput should be M by 3 or M by N by 3 +a = uint16([100 32768 3244]); +b = xyz2double(a); | | |
// float value input +a = uint16([0.0031 1.56 2.454]); +b = xyz2double(a); | | |
// error - inpput is double, no conversion takes place. +a = double([9 1 2]); +b = xyz2double(a); | | |
This function converts CIE 1931 XYZ to CIE 1976 L*a*b*.
[output] = xyz2lab(vartype)
list of color values to convert.
list of converted color values.
Convert CIE 1931 XYZ to CIE 1976 L*a*b*.
+// Convert an XYZ color value to L*a*b* +a = list(0.25, 0.40, 0.10) +xyz2lab(a) | | |
// Convert an XYZ color value to L*a*b* +a = list(0.29, 0.23, 0.11) +xyz2lab(a)) | | |
// Convert an XYZ color value to L*a*b* +a = list(0.29, 34, 0.10) +xyz2lab(a) | | |
// Convert an XYZ color value to L*a*b* +a = list(0.25, 0.56, 0.18) +xyz2lab(a) | | |
// error - inpput ahould be M by 3 or M by N by 3 +a = uint16([100 32 67 56]); +b = xyz2double(a); | | |
// Convert an XYZ color value to L*a*b* +a = list(89.25, 89.40, 0.10) +xyz2lab(a) | | |
// Convert an XYZ color value to L*a*b* +a = list(78, 89, 11) +xyz2lab(a) | | |
// Convert an XYZ color value to L*a*b* +a = list(0.25, 0.40, 90.67) +xyz2lab(a) | | |
// Convert an XYZ color value to L*a*b* +a = list(0.76, 0.67, 9.10) +xyz2lab(a) | | |
// Convert an XYZ color value to L*a*b* +a = list(78.25, 34.40, 0.10) +xyz2lab(a)) | | |
This function converts CIE 1931 XYZ to RGB.
[output] = xyz2rgb(data)
list of color values to convert.
list of converted color values.
Converts CIE 1931 XYZ to RGB.
+// Convert a color value in the XYZ color space to the sRGB color space. +a = list(0.25, 0.40, 0.10); +xyz2rgb(a) | | |
// Convert a color value in the XYZ color space to the sRGB color space. +a = list(3.25, 5.40, 12.10); +xyz2rgb(a) | | |
// Convert a color value in the XYZ color space to the sRGB color space. +a = list(2, 5, 4); +xyz2rgb(a) | | |
// Convert a color value in the XYZ color space to the sRGB color space. +a = list(0.65, 0.43, 0.19); +xyz2rgb(a) | | |
// Convert a color value in the XYZ color space to the sRGB color space. +a = list(89.25, 23, 0.6710); +xyz2rgb(a) | | |
// Convert a color value in the XYZ color space to the sRGB color space. +a = list(0.2534, 0.4340, 0.143); +xyz2rgb(a) | | |
// Convert a color value in the XYZ color space to the sRGB color space. +a = list(67.25, 34.40, 44.10); +xyz2rgb(a) | | |
// Convert a color value in the XYZ color space to the sRGB color space. +a = list(34.25, 56.40, 223.189); +xyz2rgb(a) | | |
// Convert a color value in the XYZ color space to the sRGB color space. +a = list(0.1, 0.1, 0.1); +xyz2rgb(a) | | |
// Convert a color value in the XYZ color space to the sRGB color space. +a = list(78.25, 34.40, 23.10); +xyz2rgb(a) | | |
This function converts XYZ color values to uint16.
[output] = xyz2uint16(pstData)
list of uint16 or double array that must be real and nonsparse
list of puint8.
Converts an M-by-3 or M-by-N-by-3 array of XYZ color values to uint16. output has the same size as pstData.
+// Create a double vector specifying a color in XYZ colorspace. +a = list(0.1, 0.5, 1.0) +xyz2uint16(a) | | |
// Create a double vector specifying a color in XYZ colorspace. +a = list(0.14, 0.35, 1.20) +xyz2uint16(a) | | |
// Create a double vector specifying a color in XYZ colorspace. +a = list(45.1, 22.5, 45.0) +xyz2uint16(a) | | |
// Create a double vector specifying a color in XYZ colorspace. +a = list(200, 334, 2112) +xyz2uint16(a) | | |
// Create a double vector specifying a color in XYZ colorspace. +a = list(56.1, 0.5, 1.0) +xyz2uint16(a) | | |
// Create a double vector specifying a color in XYZ colorspace. +a = list(0.1, 8378.5, 1.0) +xyz2uint16(a) | | |
// Create a double vector specifying a color in XYZ colorspace. +a = list(878.1, 32.5, 1.0) +xyz2uint16(a) | | |
// Create a double vector specifying a color in XYZ colorspace. +a = list(0.12323, 0.53434, 1.878) +xyz2uint16(a) | | |
// Create a double vector specifying a color in XYZ colorspace. +a = list(44, 55, 1.0) +xyz2uint16(a) | | |
// Create a double vector specifying a color in XYZ colorspace. +a = list(0.134, 55.5, 1.121) +xyz2uint16(a) | | |