#!/usr/bin/env python3
# -*- coding: utf-8 -*-

__author__ = "heider"
__doc__ = r"""

           Created on 01/02/2022
           """

__all__ = [
    "MarkerTypeEnum",
    "DistanceTypeEnum",
    "HoughModeEnum",
    "WindowFlagEnum",
    "ContourRetrievalModeEnum",
    "ContourApproximationModeEnum",
    "MouseEventEnum",
    "FontEnum",
    "DataTypeEnum",
    "ComparisonEnum",
    "LineTypeEnum",
    "MorphTypeEnum",
    "MorphShapeEnum",
    "DistanceTransformMaskEnum",
    "DistanceTransformLabelTypeEnum",
    "KmeansEnum",
    "CameraPropertyEnum",
    "RectanglesIntersectTypes",
    "BorderTypeEnum",
    "VideoCaptureAPIEnum",
]

from enum import Enum

import cv2


class ComparisonEnum(Enum):
    eq = cv2.CMP_EQ  # equal
    gt = cv2.CMP_GT  # greater than
    ge = cv2.CMP_GE  # # greater equal
    lt = cv2.CMP_LT  # less than
    le = cv2.CMP_LE  # less equal
    ne = cv2.CMP_NE  # unequal


class DataTypeEnum(Enum):
    # Unsigned 8bits # 	uchar	0 ~ 255
    u8 = cv2.CV_8U
    u8c1 = cv2.CV_8UC1
    u8c2 = cv2.CV_8UC2
    u8c3 = cv2.CV_8UC3
    u8c4 = cv2.CV_8UC4
    # u8cN
    # Signed 8bits	char	-128 ~ 127
    s8 = cv2.CV_8S
    s8c1 = cv2.CV_8SC1
    s8c2 = cv2.CV_8SC2
    s8c3 = cv2.CV_8SC3
    s8c4 = cv2.CV_8SC4
    # s8cN
    # Unsigned 16bits	ushort	0 ~ 65535
    u16 = cv2.CV_16U
    u16c1 = cv2.CV_16UC1
    u16c2 = cv2.CV_16UC2
    u16c3 = cv2.CV_16UC3
    u16c4 = cv2.CV_16UC4
    # u16cN
    # Signed 16bits	short	-32768 ~ 32767
    s16 = cv2.CV_16S
    s16c1 = cv2.CV_16SC1
    s16c2 = cv2.CV_16SC2
    s16c3 = cv2.CV_16SC3
    s16c4 = cv2.CV_16SC4
    # s16cN
    # Signed 32bits	int	-2147483648 ~ 2147483647
    s32 = cv2.CV_32S
    s32c1 = cv2.CV_32SC1
    s32c2 = cv2.CV_32SC2
    s32c3 = cv2.CV_32SC3
    s32c4 = cv2.CV_32SC4
    # s32cN
    # Float 32bits	float	-1.18e-38 ~ 3.40e-38
    f32 = cv2.CV_32F
    f32c1 = cv2.CV_32FC1
    f32c2 = cv2.CV_32FC2
    f32c3 = cv2.CV_32FC3
    f32c4 = cv2.CV_32FC4
    # f32cN
    # Double 64bits	double	-1.7e+308 ~ +1.7e+308
    f64 = cv2.CV_64F
    f64c1 = cv2.CV_64FC1
    f64c2 = cv2.CV_64FC2
    f64c3 = cv2.CV_64FC3
    f64c4 = cv2.CV_64FC4
    # f64cN


class VideoCaptureAPIEnum(Enum):
    """



    VideoCapture API backends identifier.
    """

    any = cv2.CAP_ANY
    # Auto detect == 0.

    vfw = cv2.CAP_VFW
    # Video For Windows (platform native)

    v4l = cv2.CAP_V4L
    # V4L/V4L2 capturing support via libv4l.

    v4l2 = cv2.CAP_V4L2
    # Same as CAP_V4L.

    firewire = cv2.CAP_FIREWIRE
    # IEEE 1394 drivers.

    fireware = cv2.CAP_FIREWARE
    # Same as CAP_FIREWIRE.

    ieee1394 = cv2.CAP_IEEE1394
    # Same as CAP_FIREWIRE.

    dc1394 = cv2.CAP_DC1394
    # Same as CAP_FIREWIRE.

    cmu1394 = cv2.CAP_CMU1394
    # Same as CAP_FIREWIRE.

    qt = cv2.CAP_QT
    # QuickTime.

    unicap = cv2.CAP_UNICAP
    # Unicap drivers.

    dshow = cv2.CAP_DSHOW
    # DirectShow (via videoInput)

    pvapi = cv2.CAP_PVAPI
    # PvAPI, Prosilica GigE SDK.

    openni = cv2.CAP_OPENNI
    # OpenNI (for Kinect)

    openni_asus = cv2.CAP_OPENNI_ASUS
    # OpenNI (for Asus Xtion)

    android = cv2.CAP_ANDROID
    # Android - not used.

    xiapi = cv2.CAP_XIAPI
    # XIMEA Camera API.

    avfoundation = cv2.CAP_AVFOUNDATION
    # AVFoundation framework for iOS (OS X Lion will have the same API)

    giganetix = cv2.CAP_GIGANETIX
    # Smartek Giganetix GigEVisionSDK.

    msmf = cv2.CAP_MSMF
    # Microsoft Media Foundation (via videoInput)

    winrt = cv2.CAP_WINRT
    # Microsoft Windows Runtime using Media Foundation.

    intelperc = cv2.CAP_INTELPERC
    # Intel Perceptual Computing SDK.

    openni2 = cv2.CAP_OPENNI2
    # OpenNI2 (for Kinect)

    openni2_asus = cv2.CAP_OPENNI2_ASUS
    # OpenNI2 (for Asus Xtion and Occipital Structure sensors)

    gphoto2 = cv2.CAP_GPHOTO2
    # gPhoto2 connection

    gstreamer = cv2.CAP_GSTREAMER
    # GStreamer.

    ffmpeg = cv2.CAP_FFMPEG
    # Open and record video file or stream using the FFMPEG library.

    images = cv2.CAP_IMAGES
    # OpenCV Image Sequence (e.g. img_%02d.jpg)

    aravis = cv2.CAP_ARAVIS
    # Aravis SDK.

    opencv_mjpeg = cv2.CAP_OPENCV_MJPEG
    # Built-in OpenCV MotionJPEG codec.

    intel_mfx = cv2.CAP_INTEL_MFX
    # Intel MediaSDK.

    xine = cv2.CAP_XINE
    # XINE engine (Linux)


class CameraPropertyEnum(Enum):
    settings = cv2.CAP_PROP_SETTINGS
    auto_focus = cv2.CAP_PROP_AUTOFOCUS
    pos_msec = (
        cv2.CAP_PROP_POS_MSEC
    )  # Current position of the video file in milliseconds.
    pos_frames = (
        cv2.CAP_PROP_POS_FRAMES
    )  # 0-based index of the frame to be decoded/captured next.
    avi_ratio = (
        cv2.CAP_PROP_POS_AVI_RATIO
    )  # Relative position of the video file: 0 - start of the film, 1 - end of the film.
    frame_width = cv2.CAP_PROP_FRAME_WIDTH  # Width of the frames in the video stream.
    frame_height = (
        cv2.CAP_PROP_FRAME_HEIGHT
    )  # Height of the frames in the video stream.
    fps = cv2.CAP_PROP_FPS  # Frame rate.
    fourcc = cv2.CAP_PROP_FOURCC  # 4-character code of codec.
    frame_count = cv2.CAP_PROP_FRAME_COUNT  # Number of frames in the video file.
    format = cv2.CAP_PROP_FORMAT  # Format of the Mat objects returned by retrieve() .
    mode = (
        cv2.CAP_PROP_MODE
    )  # Backend-specific value indicating the current capture mode.
    brightness = cv2.CAP_PROP_BRIGHTNESS  # Brightness of the image (only for cameras).
    contrast = cv2.CAP_PROP_CONTRAST  # Contrast of the image (only for cameras).
    saturation = cv2.CAP_PROP_SATURATION  # Saturation of the image (only for cameras).
    hue = cv2.CAP_PROP_HUE  # Hue of the image (only for cameras).
    gain = cv2.CAP_PROP_GAIN  # Gain of the image (only for cameras).
    exposure = cv2.CAP_PROP_EXPOSURE  # Exposure (only for cameras).
    convert_rgb = (
        cv2.CAP_PROP_CONVERT_RGB
    )  # Boolean flags indicating whether images should be converted to RGB.
    white_balance_blue = cv2.CAP_PROP_WHITE_BALANCE_BLUE_U  # Currently unsupported
    white_balance_red = cv2.CAP_PROP_WHITE_BALANCE_RED_V  # Currently unsupported
    white_balance_ios = cv2.CAP_PROP_IOS_DEVICE_WHITEBALANCE  # Currently unsupported
    rectification = (
        cv2.CAP_PROP_RECTIFICATION
    )  # Rectification flag for stereo cameras (note: only supported by DC1394 v 2.x backend currently)
    monochrome = cv2.CAP_PROP_MONOCHROME
    sharpness = cv2.CAP_PROP_SHARPNESS
    gamma = cv2.CAP_PROP_GAMMA
    temperature = cv2.CAP_PROP_TEMPERATURE
    trigger = cv2.CAP_PROP_TRIGGER
    trigger_delay = cv2.CAP_PROP_TRIGGER_DELAY
    zoom = cv2.CAP_PROP_ZOOM
    focus = cv2.CAP_PROP_FOCUS
    guid = cv2.CAP_PROP_GUID
    iso_speed = cv2.CAP_PROP_ISO_SPEED
    backlight = cv2.CAP_PROP_BACKLIGHT
    pan = cv2.CAP_PROP_PAN
    tilt = cv2.CAP_PROP_TILT
    roll = cv2.CAP_PROP_ROLL
    iris = cv2.CAP_PROP_IRIS
    buffer_size = cv2.CAP_PROP_BUFFERSIZE
    sar_num = cv2.CAP_PROP_SAR_NUM
    sar_den = cv2.CAP_PROP_SAR_DEN
    backend = cv2.CAP_PROP_BACKEND
    channel = cv2.CAP_PROP_CHANNEL
    auto_wb = cv2.CAP_PROP_AUTO_WB
    wb_temperature = cv2.CAP_PROP_WB_TEMPERATURE
    codec_pixel_format = cv2.CAP_PROP_CODEC_PIXEL_FORMAT
    bitrate = cv2.CAP_PROP_BITRATE
    orientation_meta = cv2.CAP_PROP_ORIENTATION_META
    orientation_auto = cv2.CAP_PROP_ORIENTATION_AUTO
    open_timeout_msec = cv2.CAP_PROP_OPEN_TIMEOUT_MSEC
    read_timeout_msec = cv2.CAP_PROP_READ_TIMEOUT_MSEC
    stream_open_time_usec = cv2.CAP_PROP_STREAM_OPEN_TIME_USEC
    video_total_channels = cv2.CAP_PROP_VIDEO_TOTAL_CHANNELS
    video_stream = cv2.CAP_PROP_VIDEO_STREAM
    audio_stream = cv2.CAP_PROP_AUDIO_STREAM
    audio_pos = cv2.CAP_PROP_AUDIO_POS
    audio_shift_nsec = cv2.CAP_PROP_AUDIO_SHIFT_NSEC
    audio_data_depth = cv2.CAP_PROP_AUDIO_DATA_DEPTH
    audio_samples_per_second = cv2.CAP_PROP_AUDIO_SAMPLES_PER_SECOND
    audio_base_index = cv2.CAP_PROP_AUDIO_BASE_INDEX
    audio_total_channels = cv2.CAP_PROP_AUDIO_TOTAL_CHANNELS
    audio_total_streams = cv2.CAP_PROP_AUDIO_TOTAL_STREAMS
    audio_synchronize = cv2.CAP_PROP_AUDIO_SYNCHRONIZE
    lrf_has_key_frame = cv2.CAP_PROP_LRF_HAS_KEY_FRAME
    codec_extradata_index = cv2.CAP_PROP_CODEC_EXTRADATA_INDEX


class MarkerTypeEnum(Enum):
    cross = cv2.MARKER_CROSS  # A crosshair marker shape.
    tilted_cross = cv2.MARKER_TILTED_CROSS  # A 45 degree tilted crosshair marker shape.
    star = (
        cv2.MARKER_STAR
    )  # A star marker shape, combination of cross and tilted cross.
    diamond = cv2.MARKER_DIAMOND  # A diamond marker shape.
    square = cv2.MARKER_SQUARE  # A square marker shape.
    triangle_up = cv2.MARKER_TRIANGLE_UP  # An upwards pointing triangle marker shape.
    triangle_down = (
        cv2.MARKER_TRIANGLE_DOWN
    )  # A downwards pointing triangle marker shape.


class DistanceTypeEnum(Enum):
    user = cv2.DIST_USER  # User defined distance.
    l1 = cv2.DIST_L1  # distance = |x1-x2| + |y1-y2|
    l2 = cv2.DIST_L2  # the simple euclidean distance
    c = cv2.DIST_C  # distance = max(|x1-x2|,|y1-y2|)
    l12 = cv2.DIST_L12  # L1-L2 metric: distance = 2(sqrt(1+x*x/2) - 1))
    fair = cv2.DIST_FAIR  # distance = c^2(|x|/c-log(1+|x|/c)), c = 1.3998
    welsch = cv2.DIST_WELSCH  # distance = c^2/2(1-exp(-(x/c)^2)), c = 2.9846
    huber = cv2.DIST_HUBER  # distance = |x|<c ? x^2/2 : c(|x|-c/2), c=1.345


class DistanceTransformLabelTypeEnum(Enum):
    """
    distanceTransform algorithm flags
    """

    ccomp = cv2.DIST_LABEL_CCOMP
    """each connected component of zeros in src (as well as all the non-zero pixels closest to the connected component) will be assigned the same label
"""

    pixel = cv2.DIST_LABEL_PIXEL
    """each zero pixel (and all the non-zero pixels closest to it) gets its own label."""


class BorderTypeEnum(Enum):
    """
    Various border types, image boundaries are denoted with |
    """

    constant = cv2.BORDER_CONSTANT  # iiiiii|abcdefgh|iiiiiii with some specified i
    replicate = cv2.BORDER_REPLICATE  # aaaaaa|abcdefgh|hhhhhhh
    reflect = cv2.BORDER_REFLECT  # fedcba|abcdefgh|hgfedcb
    wrap = cv2.BORDER_WRAP  # cdefgh|abcdefgh|abcdefg
    reflect_101 = cv2.BORDER_REFLECT_101  # gfedcb|abcdefgh|gfedcba
    transparent = cv2.BORDER_TRANSPARENT  # uvwxyz|abcdefgh|ijklmno
    reflect101 = cv2.BORDER_REFLECT101  # same as BORDER_REFLECT_101
    default = cv2.BORDER_DEFAULT  # same as BORDER_REFLECT_101
    isolated = cv2.BORDER_ISOLATED  # do not look outside of ROI


class DistanceTransformMaskEnum(Enum):
    """
    Mask size for distance transform.
    """

    mask_3 = cv2.DIST_MASK_3
    mask_5 = cv2.DIST_MASK_5
    mask_precise = cv2.DIST_MASK_PRECISE


class KmeansEnum(Enum):
    random_centers = (
        cv2.KMEANS_RANDOM_CENTERS
    )  # Select random initial centers in each attempt.
    pp_centers = (
        cv2.KMEANS_PP_CENTERS
    )  # Use kmeans++ center initialization by Arthur and Vassilvitskii [Arthur2007].
    use_initial_labels = (
        cv2.KMEANS_USE_INITIAL_LABELS
    )  # During the first (and possibly the only) attempt, use the user-supplied labels instead of computing them from the initial centers. For the second and further attempts, use the random or semi-random centers. Use one of KMEANS_*_CENTERS flag to specify the exact method.


class HoughModeEnum(Enum):
    standard = (
        cv2.HOUGH_STANDARD
    )  # classical or standard Hough transform. Every line is represented by two floating-point numbers (ρ,θ) , where ρ is a distance between (0,0) point and the line, and θ is the angle between x-axis and the normal to the line. Thus, the matrix must be (the created sequence will be) of CV_32FC2 type
    gradient = cv2.HOUGH_GRADIENT  # basically 21HT
    probabilistic = (
        cv2.HOUGH_PROBABILISTIC
    )  # probabilistic Hough transform (more efficient in case if the picture contains a few long linear segments). It returns line segments rather than the whole line. Each segment is represented by starting and ending points, and the matrix must be (the created sequence will be) of the CV_32SC4 type.
    multi_scale = (
        cv2.HOUGH_MULTI_SCALE
    )  # multi-scale variant of the classical Hough transform. The lines are encoded the same way as HOUGH_STANDARD.
    gradient_alternative = (
        cv2.HOUGH_GRADIENT_ALT
    )  # variation of HOUGH_GRADIENT to get better accuracy


class WindowFlagEnum(Enum):
    normal = (
        cv2.WINDOW_NORMAL
    )  # the user can resize the window (no constraint) / also use to switch a fullscreen window to a normal size.
    autosize = (
        cv2.WINDOW_AUTOSIZE
    )  # the user cannot resize the window, the size is constrainted by the image displayed.
    opengl = cv2.WINDOW_OPENGL  # window with opengl support.
    fullscreen = cv2.WINDOW_FULLSCREEN  # change the window to fullscreen.
    free_ratio = (
        cv2.WINDOW_FREERATIO
    )  # the image expends as much as it can (no ratio constraint).
    keep_ratio = cv2.WINDOW_KEEPRATIO  # the ratio of the image is respected.
    gui_expanded = cv2.WINDOW_GUI_EXPANDED  # status bar and tool bar
    gui_normal = cv2.WINDOW_GUI_NORMAL  # old fashious way


class MorphShapeEnum(Enum):
    rect = cv2.MORPH_RECT  # a rectangular structuring element: Eij=1
    cross = (
        cv2.MORPH_CROSS
    )  # a cross-shaped structuring element: Eij={10if i=anchor.y or j=anchor.x otherwise
    ellipse = (
        cv2.MORPH_ELLIPSE
    )  # an elliptic structuring element, that is, a filled ellipse inscribed into the rectangle Rect(0, 0, esize.width, 0.esize.height)


class RectanglesIntersectTypes(Enum):
    """
    types of intersection between rectangles
    """

    none = cv2.INTERSECT_NONE
    # No intersection.

    partial = cv2.INTERSECT_PARTIAL
    # There is a partial intersection.

    full = cv2.INTERSECT_FULL
    # One of the rectangle is fully enclosed in the other.


class MorphTypeEnum(Enum):
    erode = cv2.MORPH_ERODE
    dilate = cv2.MORPH_DILATE
    open = cv2.MORPH_OPEN  # dst=open(src,element)=dilate(erode(src,element))
    close = cv2.MORPH_CLOSE  # dst=close(src,element)=erode(dilate(src,element))
    gradient = (
        cv2.MORPH_GRADIENT
    )  # dst=morph_grad(src,element)=dilate(src,element)−erode(src,element)
    tophat = cv2.MORPH_TOPHAT  # dst=tophat(src,element)=src−open(src,element)
    blackhat = cv2.MORPH_BLACKHAT  # dst=blackhat(src,element)=close(src,element)−src
    hitmiss = cv2.MORPH_HITMISS  # Only supported for CV_8UC1 binary images.


class FontEnum(Enum):
    hershey_simplex = cv2.FONT_HERSHEY_SIMPLEX  # normal size sans-serif font

    hershey_plain = cv2.FONT_HERSHEY_PLAIN  # small size sans-serif font

    hershey_duplex = (
        cv2.FONT_HERSHEY_DUPLEX
    )  # normal size sans-serif font (more complex than FONT_HERSHEY_SIMPLEX)

    hershey_complex = cv2.FONT_HERSHEY_COMPLEX  # normal size serif font

    hershey_triplex = (
        cv2.FONT_HERSHEY_TRIPLEX
    )  # normal size serif font (more complex than FONT_HERSHEY_COMPLEX)

    hershey_complex_small = (
        cv2.FONT_HERSHEY_COMPLEX_SMALL
    )  # smaller version of FONT_HERSHEY_COMPLEX

    hershey_script_simplex = cv2.FONT_HERSHEY_SCRIPT_SIMPLEX  # hand-writing style font

    hershey_script_complex = (
        cv2.FONT_HERSHEY_SCRIPT_COMPLEX
    )  # more complex variant of FONT_HERSHEY_SCRIPT_SIMPLEX

    italic = cv2.FONT_ITALIC  # flag for italic font


class ContourRetrievalModeEnum(Enum):
    """

      RETR_EXTERNAL retrieves only the extreme outer contours. It sets hierarchy[i][2]=hierarchy[i][3]=-1 for all the contours.
    RETR_LIST retrieves all of the contours without establishing any hierarchical relationships.
    RETR_CCOMP retrieves all of the contours and organizes them into a two-level hierarchy. At the top level, there are external boundaries of the components. At the second level, there are boundaries of the holes. If there is another contour inside a hole of a connected component, it is still put at the top level.
    RETR_TREE retrieves all of the contours and reconstructs a full hierarchy of nested contours. This full hierarchy is built and shown in the OpenCV contours.c demo.

      :return:
      :rtype:
    """

    external = cv2.RETR_EXTERNAL
    list_all = cv2.RETR_LIST
    ccomp = cv2.RETR_CCOMP
    tree = cv2.RETR_TREE


class ContourApproximationModeEnum(Enum):
    """
    the contour approximation algorithm
    """

    none = cv2.CHAIN_APPROX_NONE
    # stores absolutely all the contour points. That is, any 2 subsequent points (x1,y1) and (x2,y2) of the contour will be either horizontal, vertical or diagonal neighbors, that is, max(abs(x1-x2),abs(y2-y1))==1.

    simple = cv2.CHAIN_APPROX_SIMPLE
    # compresses horizontal, vertical, and diagonal segments and leaves only their end points. For example, an up-right rectangular contour is encoded with 4 points.

    tc89_l1 = cv2.CHAIN_APPROX_TC89_L1
    # applies one of the flavors of the Teh-Chin chain approximation algorithm [244]

    tc89_kcos = cv2.CHAIN_APPROX_TC89_KCOS
    # applies one of the flavors of the Teh-Chin chain approximation algorithm [244]


class MouseEventEnum(Enum):
    move = (
        cv2.EVENT_MOUSEMOVE
    )  # indicates that the mouse pointer has moved over the window.
    left_down = (
        cv2.EVENT_LBUTTONDOWN
    )  # indicates that the left mouse button is pressed.
    left_up = cv2.EVENT_LBUTTONUP  # indicates that left mouse button is released.
    left_double = (
        cv2.EVENT_LBUTTONDBLCLK
    )  # indicates that left mouse button is double clicked.
    right_down = (
        cv2.EVENT_RBUTTONDOWN
    )  # indicates that the right mouse button is pressed.
    right_up = cv2.EVENT_RBUTTONUP  # indicates that right mouse button is released.
    right_double = (
        cv2.EVENT_RBUTTONDBLCLK
    )  # indicates that right mouse button is double clicked.
    middle_down = (
        cv2.EVENT_MBUTTONDOWN
    )  # indicates that the middle mouse button is pressed.
    middle_up = cv2.EVENT_MBUTTONUP  # indicates that middle mouse button is released.
    middle_double = (
        cv2.EVENT_MBUTTONDBLCLK
    )  # indicates that middle mouse button is double clicked.
    wheel_ud = (
        cv2.EVENT_MOUSEWHEEL
    )  # positive and negative values mean forward and backward scrolling, respectively.
    wheel_rl = (
        cv2.EVENT_MOUSEHWHEEL
    )  # positive and negative values mean right and left scrolling, respectively.


class LineTypeEnum(Enum):
    filled = cv2.FILLED
    line4 = cv2.LINE_4  # 4-connected line
    line8 = cv2.LINE_8  # 8-connected line
    anti_aliased = cv2.LINE_AA  # antialiased line


if __name__ == "__main__":
    pass
