content: 
  //
  // This file is auto-generated. Please don't modify it!
  //
  package org.opencv.highgui;
  
  import java.lang.String;
  import org.opencv.core.Mat;
  import org.opencv.core.MatOfByte;
  import org.opencv.core.MatOfInt;
  
  public class Highgui {
  
      public static final int
              CV_FONT_LIGHT = 25,
              CV_FONT_NORMAL = 50,
              CV_FONT_DEMIBOLD = 63,
              CV_FONT_BOLD = 75,
              CV_FONT_BLACK = 87,
              CV_STYLE_NORMAL = 0,
              CV_STYLE_ITALIC = 1,
              CV_STYLE_OBLIQUE = 2,
              CV_LOAD_IMAGE_UNCHANGED = -1,
              CV_LOAD_IMAGE_GRAYSCALE = 0,
              CV_LOAD_IMAGE_COLOR = 1,
              CV_LOAD_IMAGE_ANYDEPTH = 2,
              CV_LOAD_IMAGE_ANYCOLOR = 4,
              CV_IMWRITE_JPEG_QUALITY = 1,
              CV_IMWRITE_PNG_COMPRESSION = 16,
              CV_IMWRITE_PNG_STRATEGY = 17,
              CV_IMWRITE_PNG_BILEVEL = 18,
              CV_IMWRITE_PNG_STRATEGY_DEFAULT = 0,
              CV_IMWRITE_PNG_STRATEGY_FILTERED = 1,
              CV_IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY = 2,
              CV_IMWRITE_PNG_STRATEGY_RLE = 3,
              CV_IMWRITE_PNG_STRATEGY_FIXED = 4,
              CV_IMWRITE_PXM_BINARY = 32,
              CV_CVTIMG_FLIP = 1,
              CV_CVTIMG_SWAP_RB = 2,
              CV_CAP_MSMF = 1400,
              CV_CAP_ANDROID = 1000,
              CV_CAP_ANDROID_BACK = CV_CAP_ANDROID+99,
              CV_CAP_ANDROID_FRONT = CV_CAP_ANDROID+98,
              CV_CAP_XIAPI = 1100,
              CV_CAP_AVFOUNDATION = 1200,
              CV_CAP_GIGANETIX = 1300,
              CV_CAP_PROP_FRAME_WIDTH = 3,
              CV_CAP_PROP_FRAME_HEIGHT = 4,
              CV_CAP_PROP_ZOOM = 27,
              CV_CAP_PROP_FOCUS = 28,
              CV_CAP_PROP_GUID = 29,
              CV_CAP_PROP_ISO_SPEED = 30,
              CV_CAP_PROP_BACKLIGHT = 32,
              CV_CAP_PROP_PAN = 33,
              CV_CAP_PROP_TILT = 34,
              CV_CAP_PROP_ROLL = 35,
              CV_CAP_PROP_IRIS = 36,
              CV_CAP_PROP_SETTINGS = 37,
              CV_CAP_PROP_AUTOGRAB = 1024,
              CV_CAP_PROP_PREVIEW_FORMAT = 1026,
              CV_CAP_PROP_XI_DOWNSAMPLING = 400,
              CV_CAP_PROP_XI_DATA_FORMAT = 401,
              CV_CAP_PROP_XI_OFFSET_X = 402,
              CV_CAP_PROP_XI_OFFSET_Y = 403,
              CV_CAP_PROP_XI_TRG_SOURCE = 404,
              CV_CAP_PROP_XI_TRG_SOFTWARE = 405,
              CV_CAP_PROP_XI_GPI_SELECTOR = 406,
              CV_CAP_PROP_XI_GPI_MODE = 407,
              CV_CAP_PROP_XI_GPI_LEVEL = 408,
              CV_CAP_PROP_XI_GPO_SELECTOR = 409,
              CV_CAP_PROP_XI_GPO_MODE = 410,
              CV_CAP_PROP_XI_LED_SELECTOR = 411,
              CV_CAP_PROP_XI_LED_MODE = 412,
              CV_CAP_PROP_XI_MANUAL_WB = 413,
              CV_CAP_PROP_XI_AUTO_WB = 414,
              CV_CAP_PROP_XI_AEAG = 415,
              CV_CAP_PROP_XI_EXP_PRIORITY = 416,
              CV_CAP_PROP_XI_AE_MAX_LIMIT = 417,
              CV_CAP_PROP_XI_AG_MAX_LIMIT = 418,
              CV_CAP_PROP_XI_AEAG_LEVEL = 419,
              CV_CAP_PROP_XI_TIMEOUT = 420,
              CV_CAP_PROP_ANDROID_FLASH_MODE = 8001,
              CV_CAP_PROP_ANDROID_FOCUS_MODE = 8002,
              CV_CAP_PROP_ANDROID_WHITE_BALANCE = 8003,
              CV_CAP_PROP_ANDROID_ANTIBANDING = 8004,
              CV_CAP_PROP_ANDROID_FOCAL_LENGTH = 8005,
              CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_NEAR = 8006,
              CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_OPTIMAL = 8007,
              CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_FAR = 8008,
              CV_CAP_PROP_ANDROID_EXPOSE_LOCK = 8009,
              CV_CAP_PROP_ANDROID_WHITEBALANCE_LOCK = 8010,
              CV_CAP_PROP_IOS_DEVICE_FOCUS = 9001,
              CV_CAP_PROP_IOS_DEVICE_EXPOSURE = 9002,
              CV_CAP_PROP_IOS_DEVICE_FLASH = 9003,
              CV_CAP_PROP_IOS_DEVICE_WHITEBALANCE = 9004,
              CV_CAP_PROP_IOS_DEVICE_TORCH = 9005,
              CV_CAP_PROP_GIGA_FRAME_OFFSET_X = 10001,
              CV_CAP_PROP_GIGA_FRAME_OFFSET_Y = 10002,
              CV_CAP_PROP_GIGA_FRAME_WIDTH_MAX = 10003,
              CV_CAP_PROP_GIGA_FRAME_HEIGH_MAX = 10004,
              CV_CAP_PROP_GIGA_FRAME_SENS_WIDTH = 10005,
              CV_CAP_PROP_GIGA_FRAME_SENS_HEIGH = 10006,
              CV_CAP_PROP_INTELPERC_PROFILE_COUNT = 11001,
              CV_CAP_PROP_INTELPERC_PROFILE_IDX = 11002,
              CV_CAP_PROP_INTELPERC_DEPTH_LOW_CONFIDENCE_VALUE = 11003,
              CV_CAP_PROP_INTELPERC_DEPTH_SATURATION_VALUE = 11004,
              CV_CAP_PROP_INTELPERC_DEPTH_CONFIDENCE_THRESHOLD = 11005,
              CV_CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_HORZ = 11006,
              CV_CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_VERT = 11007,
              CV_CAP_ANDROID_COLOR_FRAME_BGR = 0,
              CV_CAP_ANDROID_COLOR_FRAME = CV_CAP_ANDROID_COLOR_FRAME_BGR,
              CV_CAP_ANDROID_GREY_FRAME = 1,
              CV_CAP_ANDROID_COLOR_FRAME_RGB = 2,
              CV_CAP_ANDROID_COLOR_FRAME_BGRA = 3,
              CV_CAP_ANDROID_COLOR_FRAME_RGBA = 4,
              CV_CAP_ANDROID_FLASH_MODE_AUTO = 0,
              CV_CAP_ANDROID_FLASH_MODE_OFF = 0+1,
              CV_CAP_ANDROID_FLASH_MODE_ON = 0+2,
              CV_CAP_ANDROID_FLASH_MODE_RED_EYE = 0+3,
              CV_CAP_ANDROID_FLASH_MODE_TORCH = 0+4,
              CV_CAP_ANDROID_FOCUS_MODE_AUTO = 0,
              CV_CAP_ANDROID_FOCUS_MODE_CONTINUOUS_PICTURE = 0+1,
              CV_CAP_ANDROID_FOCUS_MODE_CONTINUOUS_VIDEO = 0+2,
              CV_CAP_ANDROID_FOCUS_MODE_EDOF = 0+3,
              CV_CAP_ANDROID_FOCUS_MODE_FIXED = 0+4,
              CV_CAP_ANDROID_FOCUS_MODE_INFINITY = 0+5,
              CV_CAP_ANDROID_FOCUS_MODE_MACRO = 0+6,
              CV_CAP_ANDROID_WHITE_BALANCE_AUTO = 0,
              CV_CAP_ANDROID_WHITE_BALANCE_CLOUDY_DAYLIGHT = 0+1,
              CV_CAP_ANDROID_WHITE_BALANCE_DAYLIGHT = 0+2,
              CV_CAP_ANDROID_WHITE_BALANCE_FLUORESCENT = 0+3,
              CV_CAP_ANDROID_WHITE_BALANCE_INCANDESCENT = 0+4,
              CV_CAP_ANDROID_WHITE_BALANCE_SHADE = 0+5,
              CV_CAP_ANDROID_WHITE_BALANCE_TWILIGHT = 0+6,
              CV_CAP_ANDROID_WHITE_BALANCE_WARM_FLUORESCENT = 0+7,
              CV_CAP_ANDROID_ANTIBANDING_50HZ = 0,
              CV_CAP_ANDROID_ANTIBANDING_60HZ = 0+1,
              CV_CAP_ANDROID_ANTIBANDING_AUTO = 0+2,
              CV_CAP_ANDROID_ANTIBANDING_OFF = 0+3,
              IMREAD_UNCHANGED = -1,
              IMREAD_GRAYSCALE = 0,
              IMREAD_COLOR = 1,
              IMREAD_ANYDEPTH = 2,
              IMREAD_ANYCOLOR = 4,
              IMWRITE_JPEG_QUALITY = 1,
              IMWRITE_PNG_COMPRESSION = 16,
              IMWRITE_PNG_STRATEGY = 17,
              IMWRITE_PNG_BILEVEL = 18,
              IMWRITE_PNG_STRATEGY_DEFAULT = 0,
              IMWRITE_PNG_STRATEGY_FILTERED = 1,
              IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY = 2,
              IMWRITE_PNG_STRATEGY_RLE = 3,
              IMWRITE_PNG_STRATEGY_FIXED = 4,
              IMWRITE_PXM_BINARY = 32;
  
  
      //
      // C++:  Mat imdecode(Mat buf, int flags)
      //
  
  /**
   * <p>Reads an image from a buffer in memory.</p>
   *
   * <p>The function reads an image from the specified buffer in the memory.
   * If the buffer is too short or contains invalid data, the empty matrix/image
   * is returned.</p>
   *
   * <p>See "imread" for the list of supported formats and flags description.</p>
   *
   * <p>Note: In the case of color images, the decoded images will have the channels
   * stored in <code>B G R</code> order.</p>
   *
   * @param buf Input array or vector of bytes.
   * @param flags The same flags as in "imread".
   *
   * @see <a href="http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#imdecode">org.opencv.highgui.Highgui.imdecode</a>
   */
      public static Mat imdecode(Mat buf, int flags)
      {
  
          Mat retVal = new Mat(imdecode_0(buf.nativeObj, flags));
  
          return retVal;
      }
  
  
      //
      // C++:  bool imencode(string ext, Mat img, vector_uchar& buf, vector_int params = vector<int>())
      //
  
  /**
   * <p>Encodes an image into a memory buffer.</p>
   *
   * <p>The function compresses the image and stores it in the memory buffer that is
   * resized to fit the result.
   * See "imwrite" for the list of supported formats and flags description.</p>
   *
   * <p>Note: <code>cvEncodeImage</code> returns single-row matrix of type
   * <code>CV_8UC1</code> that contains encoded image as array of bytes.</p>
   *
   * @param ext File extension that defines the output format.
   * @param img Image to be written.
   * @param buf Output buffer resized to fit the compressed image.
   * @param params Format-specific parameters. See "imwrite".
   *
   * @see <a href="http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#imencode">org.opencv.highgui.Highgui.imencode</a>
   */
      public static boolean imencode(String ext, Mat img, MatOfByte buf, MatOfInt params)
      {
          Mat buf_mat = buf;
          Mat params_mat = params;
          boolean retVal = imencode_0(ext, img.nativeObj, buf_mat.nativeObj, params_mat.nativeObj);
  
          return retVal;
      }
  
  /**
   * <p>Encodes an image into a memory buffer.</p>
   *
   * <p>The function compresses the image and stores it in the memory buffer that is
   * resized to fit the result.
   * See "imwrite" for the list of supported formats and flags description.</p>
   *
   * <p>Note: <code>cvEncodeImage</code> returns single-row matrix of type
   * <code>CV_8UC1</code> that contains encoded image as array of bytes.</p>
   *
   * @param ext File extension that defines the output format.
   * @param img Image to be written.
   * @param buf Output buffer resized to fit the compressed image.
   *
   * @see <a href="http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#imencode">org.opencv.highgui.Highgui.imencode</a>
   */
      public static boolean imencode(String ext, Mat img, MatOfByte buf)
      {
          Mat buf_mat = buf;
          boolean retVal = imencode_1(ext, img.nativeObj, buf_mat.nativeObj);
  
          return retVal;
      }
  
  
      //
      // C++:  Mat imread(string filename, int flags = 1)
      //
  
  /**
   * <p>Loads an image from a file.</p>
   *
   * <p>The function <code>imread</code> loads an image from the specified file and
   * returns it. If the image cannot be read (because of missing file, improper
   * permissions, unsupported or invalid format), the function returns an empty
   * matrix (<code>Mat.data==NULL</code>). Currently, the following file formats
   * are supported:</p>
   * <ul>
   *   <li> Windows bitmaps - <code>*.bmp, *.dib</code> (always supported)
   *   <li> JPEG files - <code>*.jpeg, *.jpg, *.jpe</code> (see the *Notes*
   * section)
   *   <li> JPEG 2000 files - <code>*.jp2</code> (see the *Notes* section)
   *   <li> Portable Network Graphics - <code>*.png</code> (see the *Notes*
   * section)
   *   <li> Portable image format - <code>*.pbm, *.pgm, *.ppm</code> (always
   * supported)
   *   <li> Sun rasters - <code>*.sr, *.ras</code> (always supported)
   *   <li> TIFF files - <code>*.tiff, *.tif</code> (see the *Notes* section)
   * </ul>
   *
   * <p>Note:</p>
   * <ul>
   *   <li> The function determines the type of an image by the content, not by
   * the file extension.
   *   <li> On Microsoft Windows* OS and MacOSX*, the codecs shipped with an
   * OpenCV image (libjpeg, libpng, libtiff, and libjasper) are used by default.
   * So, OpenCV can always read JPEGs, PNGs, and TIFFs. On MacOSX, there is also
   * an option to use native MacOSX image readers. But beware that currently these
   * native image loaders give images with different pixel values because of the
   * color management embedded into MacOSX.
   *   <li> On Linux*, BSD flavors and other Unix-like open-source operating
   * systems, OpenCV looks for codecs supplied with an OS image. Install the
   * relevant packages (do not forget the development files, for example,
   * "libjpeg-dev", in Debian* and Ubuntu*) to get the codec support or turn on
   * the <code>OPENCV_BUILD_3RDPARTY_LIBS</code> flag in CMake.
   * </ul>
   *
   * <p>Note: In the case of color images, the decoded images will have the channels
   * stored in <code>B G R</code> order.</p>
   *
   * @param filename Name of file to be loaded.
   * @param flags Flags specifying the color type of a loaded image:
   * <ul>
   *   <li> CV_LOAD_IMAGE_ANYDEPTH - If set, return 16-bit/32-bit image when the
   * input has the corresponding depth, otherwise convert it to 8-bit.
   *   <li> CV_LOAD_IMAGE_COLOR - If set, always convert image to the color one
   *   <li> CV_LOAD_IMAGE_GRAYSCALE - If set, always convert image to the
   * grayscale one
   *   <li> >0 Return a 3-channel color image.
   * </ul>
   * <p>Note: In the current implementation the alpha channel, if any, is stripped
   * from the output image. Use negative value if you need the alpha channel.</p>
   * <ul>
   *   <li> =0 Return a grayscale image.
   *   <li> <0 Return the loaded image as is (with alpha channel).
   * </ul>
   *
   * @see <a href="http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#imread">org.opencv.highgui.Highgui.imread</a>
   */
      public static Mat imread(String filename, int flags)
      {
  
          Mat retVal = new Mat(imread_0(filename, flags));
  
          return retVal;
      }
  
  /**
   * <p>Loads an image from a file.</p>
   *
   * <p>The function <code>imread</code> loads an image from the specified file and
   * returns it. If the image cannot be read (because of missing file, improper
   * permissions, unsupported or invalid format), the function returns an empty
   * matrix (<code>Mat.data==NULL</code>). Currently, the following file formats
   * are supported:</p>
   * <ul>
   *   <li> Windows bitmaps - <code>*.bmp, *.dib</code> (always supported)
   *   <li> JPEG files - <code>*.jpeg, *.jpg, *.jpe</code> (see the *Notes*
   * section)
   *   <li> JPEG 2000 files - <code>*.jp2</code> (see the *Notes* section)
   *   <li> Portable Network Graphics - <code>*.png</code> (see the *Notes*
   * section)
   *   <li> Portable image format - <code>*.pbm, *.pgm, *.ppm</code> (always
   * supported)
   *   <li> Sun rasters - <code>*.sr, *.ras</code> (always supported)
   *   <li> TIFF files - <code>*.tiff, *.tif</code> (see the *Notes* section)
   * </ul>
   *
   * <p>Note:</p>
   * <ul>
   *   <li> The function determines the type of an image by the content, not by
   * the file extension.
   *   <li> On Microsoft Windows* OS and MacOSX*, the codecs shipped with an
   * OpenCV image (libjpeg, libpng, libtiff, and libjasper) are used by default.
   * So, OpenCV can always read JPEGs, PNGs, and TIFFs. On MacOSX, there is also
   * an option to use native MacOSX image readers. But beware that currently these
   * native image loaders give images with different pixel values because of the
   * color management embedded into MacOSX.
   *   <li> On Linux*, BSD flavors and other Unix-like open-source operating
   * systems, OpenCV looks for codecs supplied with an OS image. Install the
   * relevant packages (do not forget the development files, for example,
   * "libjpeg-dev", in Debian* and Ubuntu*) to get the codec support or turn on
   * the <code>OPENCV_BUILD_3RDPARTY_LIBS</code> flag in CMake.
   * </ul>
   *
   * <p>Note: In the case of color images, the decoded images will have the channels
   * stored in <code>B G R</code> order.</p>
   *
   * @param filename Name of file to be loaded.
   *
   * @see <a href="http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#imread">org.opencv.highgui.Highgui.imread</a>
   */
      public static Mat imread(String filename)
      {
  
          Mat retVal = new Mat(imread_1(filename));
  
          return retVal;
      }
  
  
      //
      // C++:  bool imwrite(string filename, Mat img, vector_int params = vector<int>())
      //
  
  /**
   * <p>Saves an image to a specified file.</p>
   *
   * <p>The function <code>imwrite</code> saves the image to the specified file. The
   * image format is chosen based on the <code>filename</code> extension (see
   * "imread" for the list of extensions). Only 8-bit (or 16-bit unsigned
   * (<code>CV_16U</code>) in case of PNG, JPEG 2000, and TIFF) single-channel or
   * 3-channel (with 'BGR' channel order) images can be saved using this function.
   * If the format, depth or channel order is different, use "Mat.convertTo", and
   * "cvtColor" to convert it before saving. Or, use the universal "FileStorage"
   * I/O functions to save the image to XML or YAML format.
   * It is possible to store PNG images with an alpha channel using this function.
   * To do this, create 8-bit (or 16-bit) 4-channel image BGRA, where the alpha
   * channel goes last. Fully transparent pixels should have alpha set to 0, fully
   * opaque pixels should have alpha set to 255/65535. The sample below shows how
   * to create such a BGRA image and store to PNG file. It also demonstrates how
   * to set custom compression parameters <code></p>
   *
   * <p>// C++ code:</p>
   *
   * <p>#include <vector></p>
   *
   * <p>#include <stdio.h></p>
   *
   * <p>#include <opencv2/opencv.hpp></p>
   *
   * <p>using namespace cv;</p>
   *
   * <p>using namespace std;</p>
   *
   * <p>void createAlphaMat(Mat &mat)</p>
   *
   *
   * <p>for (int i = 0; i < mat.rows; ++i) {</p>
   *
   * <p>for (int j = 0; j < mat.cols; ++j) {</p>
   *
   * <p>Vec4b& rgba = mat.at<Vec4b>(i, j);</p>
   *
   * <p>rgba[0] = UCHAR_MAX;</p>
   *
   * <p>rgba[1] = saturate_cast<uchar>((float (mat.cols - j)) / ((float)mat.cols) *
   * UCHAR_MAX);</p>
   *
   * <p>rgba[2] = saturate_cast<uchar>((float (mat.rows - i)) / ((float)mat.rows) *
   * UCHAR_MAX);</p>
   *
   * <p>rgba[3] = saturate_cast<uchar>(0.5 * (rgba[1] + rgba[2]));</p>
   *
   *
   *
   *
   * <p>int main(int argv, char argc)</p>
   *
   *
   * <p>// Create mat with alpha channel</p>
   *
   * <p>Mat mat(480, 640, CV_8UC4);</p>
   *
   * <p>createAlphaMat(mat);</p>
   *
   * <p>vector<int> compression_params;</p>
   *
   * <p>compression_params.push_back(CV_IMWRITE_PNG_COMPRESSION);</p>
   *
   * <p>compression_params.push_back(9);</p>
   *
   * <p>try {</p>
   *
   * <p>imwrite("alpha.png", mat, compression_params);</p>
   *
   *
   * <p>catch (runtime_error& ex) {</p>
   *
   * <p>fprintf(stderr, "Exception converting image to PNG format: %sn", ex.what());</p>
   *
   * <p>return 1;</p>
   *
   *
   * <p>fprintf(stdout, "Saved PNG file with alpha data.n");</p>
   *
   * <p>return 0;</p>
   *
   *
   * @param filename Name of the file.
   * @param img a img
   * @param params Format-specific save parameters encoded as pairs
   * <code>paramId_1, paramValue_1, paramId_2, paramValue_2,...</code>. The
   * following parameters are currently supported:
   * <ul>
   *   <li> For JPEG, it can be a quality (<code>CV_IMWRITE_JPEG_QUALITY</code>)
   * from 0 to 100 (the higher is the better). Default value is 95.
   *   <li> For PNG, it can be the compression level (<code>CV_IMWRITE_PNG_COMPRESSION</code>)
   * from 0 to 9. A higher value means a smaller size and longer compression time.
   * Default value is 3.
   *   <li> For PPM, PGM, or PBM, it can be a binary format flag (<code>CV_IMWRITE_PXM_BINARY</code>),
   * 0 or 1. Default value is 1.
   * </ul>
   *
   * @see <a href="http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#imwrite">org.opencv.highgui.Highgui.imwrite</a>
   */
      public static boolean imwrite(String filename, Mat img, MatOfInt params)
      {
          Mat params_mat = params;
          boolean retVal = imwrite_0(filename, img.nativeObj, params_mat.nativeObj);
  
          return retVal;
      }
  
  /**
   * <p>Saves an image to a specified file.</p>
   *
   * <p>The function <code>imwrite</code> saves the image to the specified file. The
   * image format is chosen based on the <code>filename</code> extension (see
   * "imread" for the list of extensions). Only 8-bit (or 16-bit unsigned
   * (<code>CV_16U</code>) in case of PNG, JPEG 2000, and TIFF) single-channel or
   * 3-channel (with 'BGR' channel order) images can be saved using this function.
   * If the format, depth or channel order is different, use "Mat.convertTo", and
   * "cvtColor" to convert it before saving. Or, use the universal "FileStorage"
   * I/O functions to save the image to XML or YAML format.
   * It is possible to store PNG images with an alpha channel using this function.
   * To do this, create 8-bit (or 16-bit) 4-channel image BGRA, where the alpha
   * channel goes last. Fully transparent pixels should have alpha set to 0, fully
   * opaque pixels should have alpha set to 255/65535. The sample below shows how
   * to create such a BGRA image and store to PNG file. It also demonstrates how
   * to set custom compression parameters <code></p>
   *
   * <p>// C++ code:</p>
   *
   * <p>#include <vector></p>
   *
   * <p>#include <stdio.h></p>
   *
   * <p>#include <opencv2/opencv.hpp></p>
   *
   * <p>using namespace cv;</p>
   *
   * <p>using namespace std;</p>
   *
   * <p>void createAlphaMat(Mat &mat)</p>
   *
   *
   * <p>for (int i = 0; i < mat.rows; ++i) {</p>
   *
   * <p>for (int j = 0; j < mat.cols; ++j) {</p>
   *
   * <p>Vec4b& rgba = mat.at<Vec4b>(i, j);</p>
   *
   * <p>rgba[0] = UCHAR_MAX;</p>
   *
   * <p>rgba[1] = saturate_cast<uchar>((float (mat.cols - j)) / ((float)mat.cols) *
   * UCHAR_MAX);</p>
   *
   * <p>rgba[2] = saturate_cast<uchar>((float (mat.rows - i)) / ((float)mat.rows) *
   * UCHAR_MAX);</p>
   *
   * <p>rgba[3] = saturate_cast<uchar>(0.5 * (rgba[1] + rgba[2]));</p>
   *
   *
   *
   *
   * <p>int main(int argv, char argc)</p>
   *
   *
   * <p>// Create mat with alpha channel</p>
   *
   * <p>Mat mat(480, 640, CV_8UC4);</p>
   *
   * <p>createAlphaMat(mat);</p>
   *
   * <p>vector<int> compression_params;</p>
   *
   * <p>compression_params.push_back(CV_IMWRITE_PNG_COMPRESSION);</p>
   *
   * <p>compression_params.push_back(9);</p>
   *
   * <p>try {</p>
   *
   * <p>imwrite("alpha.png", mat, compression_params);</p>
   *
   *
   * <p>catch (runtime_error& ex) {</p>
   *
   * <p>fprintf(stderr, "Exception converting image to PNG format: %sn", ex.what());</p>
   *
   * <p>return 1;</p>
   *
   *
   * <p>fprintf(stdout, "Saved PNG file with alpha data.n");</p>
   *
   * <p>return 0;</p>
   *
   *
   * @param filename Name of the file.
   * @param img a img
   *
   * @see <a href="http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#imwrite">org.opencv.highgui.Highgui.imwrite</a>
   */
      public static boolean imwrite(String filename, Mat img)
      {
  
          boolean retVal = imwrite_1(filename, img.nativeObj);
  
          return retVal;
      }
  
  
  
  
      // C++:  Mat imdecode(Mat buf, int flags)
      private static native long imdecode_0(long buf_nativeObj, int flags);
  
      // C++:  bool imencode(string ext, Mat img, vector_uchar& buf, vector_int params = vector<int>())
      private static native boolean imencode_0(String ext, long img_nativeObj, long buf_mat_nativeObj, long params_mat_nativeObj);
      private static native boolean imencode_1(String ext, long img_nativeObj, long buf_mat_nativeObj);
  
      // C++:  Mat imread(string filename, int flags = 1)
      private static native long imread_0(String filename, int flags);
      private static native long imread_1(String filename);
  
      // C++:  bool imwrite(string filename, Mat img, vector_int params = vector<int>())
      private static native boolean imwrite_0(String filename, long img_nativeObj, long params_mat_nativeObj);
      private static native boolean imwrite_1(String filename, long img_nativeObj);
  
  }
  