Upload 226 files

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+doc/deepfake_progress_source.psd filter=lfs diff=lfs merge=lfs -text
+doc/deepfake_progress.png filter=lfs diff=lfs merge=lfs -text
+merger/gfx/help_merger_face_avatar_source.psd filter=lfs diff=lfs merge=lfs -text
+merger/gfx/help_merger_masked_source.psd filter=lfs diff=lfs merge=lfs -text

CODEGUIDELINES

@@ -0,0 +1,5 @@
+Please don't ruin the code and this good (as I think) architecture.
+
+Please follow the same logic and brevity/pithiness.
+
+Don't abstract the code into huge classes if you only win some lines of code in one place, because this can prevent programmers from understanding it quickly.

DFLIMG/DFLIMG.py

@@ -0,0 +1,12 @@
+from pathlib import Path
+
+from .DFLJPG import DFLJPG
+
+class DFLIMG():
+
+    @staticmethod
+    def load(filepath, loader_func=None):
+        if filepath.suffix == '.jpg':
+            return DFLJPG.load ( str(filepath), loader_func=loader_func )
+        else:
+            return None

DFLIMG/DFLJPG.py

@@ -0,0 +1,324 @@
+import pickle
+import struct
+import traceback
+
+import cv2
+import numpy as np
+
+from core import imagelib
+from core.cv2ex import *
+from core.imagelib import SegIEPolys
+from core.interact import interact as io
+from core.structex import *
+from facelib import FaceType
+
+
+class DFLJPG(object):
+    def __init__(self, filename):
+        self.filename = filename
+        self.data = b""
+        self.length = 0
+        self.chunks = []
+        self.dfl_dict = None
+        self.shape = None
+        self.img = None
+
+    @staticmethod
+    def load_raw(filename, loader_func=None):
+        try:
+            if loader_func is not None:
+                data = loader_func(filename)
+            else:
+                with open(filename, "rb") as f:
+                    data = f.read()
+        except:
+            raise FileNotFoundError(filename)
+
+        try:
+            inst = DFLJPG(filename)
+            inst.data = data
+            inst.length = len(data)
+            inst_length = inst.length
+            chunks = []
+            data_counter = 0
+            while data_counter < inst_length:
+                chunk_m_l, chunk_m_h = struct.unpack ("BB", data[data_counter:data_counter+2])
+                data_counter += 2
+
+                if chunk_m_l != 0xFF:
+                    raise ValueError(f"No Valid JPG info in {filename}")
+
+                chunk_name = None
+                chunk_size = None
+                chunk_data = None
+                chunk_ex_data = None
+                is_unk_chunk = False
+
+                if chunk_m_h & 0xF0 == 0xD0:
+                    n = chunk_m_h & 0x0F
+
+                    if n >= 0 and n <= 7:
+                        chunk_name = "RST%d" % (n)
+                        chunk_size = 0
+                    elif n == 0x8:
+                        chunk_name = "SOI"
+                        chunk_size = 0
+                        if len(chunks) != 0:
+                            raise Exception("")
+                    elif n == 0x9:
+                        chunk_name = "EOI"
+                        chunk_size = 0
+                    elif n == 0xA:
+                        chunk_name = "SOS"
+                    elif n == 0xB:
+                        chunk_name = "DQT"
+                    elif n == 0xD:
+                        chunk_name = "DRI"
+                        chunk_size = 2
+                    else:
+                        is_unk_chunk = True
+                elif chunk_m_h & 0xF0 == 0xC0:
+                    n = chunk_m_h & 0x0F
+                    if n == 0:
+                        chunk_name = "SOF0"
+                    elif n == 2:
+                        chunk_name = "SOF2"
+                    elif n == 4:
+                        chunk_name = "DHT"
+                    else:
+                        is_unk_chunk = True
+                elif chunk_m_h & 0xF0 == 0xE0:
+                    n = chunk_m_h & 0x0F
+                    chunk_name = "APP%d" % (n)
+                else:
+                    is_unk_chunk = True
+
+                #if is_unk_chunk:
+                #    #raise ValueError(f"Unknown chunk {chunk_m_h} in {filename}")
+                #    io.log_info(f"Unknown chunk {chunk_m_h} in {filename}")
+
+                if chunk_size == None: #variable size
+                    chunk_size, = struct.unpack (">H", data[data_counter:data_counter+2])
+                    chunk_size -= 2
+                    data_counter += 2
+
+                if chunk_size > 0:
+                    chunk_data = data[data_counter:data_counter+chunk_size]
+                    data_counter += chunk_size
+
+                if chunk_name == "SOS":
+                    c = data_counter
+                    while c < inst_length and (data[c] != 0xFF or data[c+1] != 0xD9):
+                        c += 1
+
+                    chunk_ex_data = data[data_counter:c]
+                    data_counter = c
+
+                chunks.append ({'name' : chunk_name,
+                                'm_h' : chunk_m_h,
+                                'data' : chunk_data,
+                                'ex_data' : chunk_ex_data,
+                                })
+            inst.chunks = chunks
+
+            return inst
+        except Exception as e:
+            raise Exception (f"Corrupted JPG file {filename} {e}")
+
+    @staticmethod
+    def load(filename, loader_func=None):
+        try:
+            inst = DFLJPG.load_raw (filename, loader_func=loader_func)
+            inst.dfl_dict = {}
+
+            for chunk in inst.chunks:
+                if chunk['name'] == 'APP0':
+                    d, c = chunk['data'], 0
+                    c, id, _ = struct_unpack (d, c, "=4sB")
+
+                    if id == b"JFIF":
+                        c, ver_major, ver_minor, units, Xdensity, Ydensity, Xthumbnail, Ythumbnail = struct_unpack (d, c, "=BBBHHBB")
+                    else:
+                        raise Exception("Unknown jpeg ID: %s" % (id) )
+                elif chunk['name'] == 'SOF0' or chunk['name'] == 'SOF2':
+                    d, c = chunk['data'], 0
+                    c, precision, height, width = struct_unpack (d, c, ">BHH")
+                    inst.shape = (height, width, 3)
+
+                elif chunk['name'] == 'APP15':
+                    if type(chunk['data']) == bytes:
+                        inst.dfl_dict = pickle.loads(chunk['data'])
+
+            return inst
+        except Exception as e:
+            io.log_err (f'Exception occured while DFLJPG.load : {traceback.format_exc()}')
+            return None
+
+    def has_data(self):
+        return len(self.dfl_dict.keys()) != 0
+
+    def save(self):
+        try:
+            with open(self.filename, "wb") as f:
+                f.write ( self.dump() )
+        except:
+            raise Exception( f'cannot save {self.filename}' )
+
+    def dump(self):
+        data = b""
+
+        dict_data = self.dfl_dict
+
+        # Remove None keys
+        for key in list(dict_data.keys()):
+            if dict_data[key] is None:
+                dict_data.pop(key)
+
+        for chunk in self.chunks:
+            if chunk['name'] == 'APP15':
+                self.chunks.remove(chunk)
+                break
+
+        last_app_chunk = 0
+        for i, chunk in enumerate (self.chunks):
+            if chunk['m_h'] & 0xF0 == 0xE0:
+                last_app_chunk = i
+
+        dflchunk = {'name' : 'APP15',
+                    'm_h' : 0xEF,
+                    'data' : pickle.dumps(dict_data),
+                    'ex_data' : None,
+                    }
+        self.chunks.insert (last_app_chunk+1, dflchunk)
+
+
+        for chunk in self.chunks:
+            data += struct.pack ("BB", 0xFF, chunk['m_h'] )
+            chunk_data = chunk['data']
+            if chunk_data is not None:
+                data += struct.pack (">H", len(chunk_data)+2 )
+                data += chunk_data
+
+            chunk_ex_data = chunk['ex_data']
+            if chunk_ex_data is not None:
+                data += chunk_ex_data
+
+        return data
+
+    def get_img(self):
+        if self.img is None:
+            self.img = cv2_imread(self.filename)
+        return self.img
+
+    def get_shape(self):
+        if self.shape is None:
+            img = self.get_img()
+            if img is not None:
+                self.shape = img.shape
+        return self.shape
+
+    def get_height(self):
+        for chunk in self.chunks:
+            if type(chunk) == IHDR:
+                return chunk.height
+        return 0
+
+    def get_dict(self):
+        return self.dfl_dict
+
+    def set_dict (self, dict_data=None):
+        self.dfl_dict = dict_data
+
+    def get_face_type(self):            return self.dfl_dict.get('face_type', FaceType.toString (FaceType.FULL) )
+    def set_face_type(self, face_type): self.dfl_dict['face_type'] = face_type
+
+    def get_landmarks(self):            return np.array ( self.dfl_dict['landmarks'] )
+    def set_landmarks(self, landmarks): self.dfl_dict['landmarks'] = landmarks
+
+    def get_eyebrows_expand_mod(self):                      return self.dfl_dict.get ('eyebrows_expand_mod', 1.0)
+    def set_eyebrows_expand_mod(self, eyebrows_expand_mod): self.dfl_dict['eyebrows_expand_mod'] = eyebrows_expand_mod
+
+    def get_source_filename(self):                  return self.dfl_dict.get ('source_filename', None)
+    def set_source_filename(self, source_filename): self.dfl_dict['source_filename'] = source_filename
+
+    def get_source_rect(self):              return self.dfl_dict.get ('source_rect', None)
+    def set_source_rect(self, source_rect): self.dfl_dict['source_rect'] = source_rect
+
+    def get_source_landmarks(self):                     return np.array ( self.dfl_dict.get('source_landmarks', None) )
+    def set_source_landmarks(self, source_landmarks):   self.dfl_dict['source_landmarks'] = source_landmarks
+
+    def get_image_to_face_mat(self):
+        mat = self.dfl_dict.get ('image_to_face_mat', None)
+        if mat is not None:
+            return np.array (mat)
+        return None
+    def set_image_to_face_mat(self, image_to_face_mat):   self.dfl_dict['image_to_face_mat'] = image_to_face_mat
+
+    def has_seg_ie_polys(self):
+        return self.dfl_dict.get('seg_ie_polys',None) is not None
+
+    def get_seg_ie_polys(self):
+        d = self.dfl_dict.get('seg_ie_polys',None)
+        if d is not None:
+            d = SegIEPolys.load(d)
+        else:
+            d = SegIEPolys()
+
+        return d
+
+    def set_seg_ie_polys(self, seg_ie_polys):
+        if seg_ie_polys is not None:
+            if not isinstance(seg_ie_polys, SegIEPolys):
+                raise ValueError('seg_ie_polys should be instance of SegIEPolys')
+
+            if seg_ie_polys.has_polys():
+                seg_ie_polys = seg_ie_polys.dump()
+            else:
+                seg_ie_polys = None
+
+        self.dfl_dict['seg_ie_polys'] = seg_ie_polys
+
+    def has_xseg_mask(self):
+        return self.dfl_dict.get('xseg_mask',None) is not None
+
+    def get_xseg_mask_compressed(self):
+        mask_buf = self.dfl_dict.get('xseg_mask',None)
+        if mask_buf is None:
+            return None
+
+        return mask_buf
+        
+    def get_xseg_mask(self):
+        mask_buf = self.dfl_dict.get('xseg_mask',None)
+        if mask_buf is None:
+            return None
+
+        img = cv2.imdecode(mask_buf, cv2.IMREAD_UNCHANGED)
+        if len(img.shape) == 2:
+            img = img[...,None]
+
+        return img.astype(np.float32) / 255.0
+
+
+    def set_xseg_mask(self, mask_a):
+        if mask_a is None:
+            self.dfl_dict['xseg_mask'] = None
+            return
+
+        mask_a = imagelib.normalize_channels(mask_a, 1)
+        img_data = np.clip( mask_a*255, 0, 255 ).astype(np.uint8)
+
+        data_max_len = 50000
+
+        ret, buf = cv2.imencode('.png', img_data)
+
+        if not ret or len(buf) > data_max_len:
+            for jpeg_quality in range(100,-1,-1):
+                ret, buf = cv2.imencode( '.jpg', img_data, [int(cv2.IMWRITE_JPEG_QUALITY), jpeg_quality] )
+                if ret and len(buf) <= data_max_len:
+                    break
+
+        if not ret:
+            raise Exception("set_xseg_mask: unable to generate image data for set_xseg_mask")
+
+        self.dfl_dict['xseg_mask'] = buf

DFLIMG/__init__.py

@@ -0,0 +1,2 @@
+from .DFLIMG import DFLIMG
+from .DFLJPG import DFLJPG

LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

README.md

@@ -1,3 +1,429 @@
----
-license: apache-2.0
----
+<table align="center" border="0">
+
+<tr><td colspan=2 align="center">
+
+# DeepFaceLab  
+
+<a href="https://arxiv.org/abs/2005.05535">
+
+<img src="https://static.arxiv.org/static/browse/0.3.0/images/icons/favicon.ico" width=14></img>
+https://arxiv.org/abs/2005.05535</a>
+
+
+### the leading software for creating deepfakes
+
+<img src="doc/DFL_welcome.png" align="center">
+
+</td></tr>
+<tr><td colspan=2 align="center">
+
+<p align="center">
+
+![](doc/logo_tensorflow.png)
+![](doc/logo_cuda.png)
+![](doc/logo_directx.png)
+
+</p>
+
+More than 95% of deepfake videos are created with DeepFaceLab.
+
+DeepFaceLab is used by such popular youtube channels as
+
+|![](doc/tiktok_icon.png) [deeptomcruise](https://www.tiktok.com/@deeptomcruise)|![](doc/tiktok_icon.png) [1facerussia](https://www.tiktok.com/@1facerussia)|![](doc/tiktok_icon.png) [arnoldschwarzneggar](https://www.tiktok.com/@arnoldschwarzneggar)
+|---|---|---|
+
+|![](doc/tiktok_icon.png) [mariahcareyathome?](https://www.tiktok.com/@mariahcareyathome?)|![](doc/tiktok_icon.png) [diepnep](https://www.tiktok.com/@diepnep)|![](doc/tiktok_icon.png) [mr__heisenberg](https://www.tiktok.com/@mr__heisenberg)|![](doc/tiktok_icon.png) [deepcaprio](https://www.tiktok.com/@deepcaprio)
+|---|---|---|---|
+
+|![](doc/youtube_icon.png) [VFXChris Ume](https://www.youtube.com/channel/UCGf4OlX_aTt8DlrgiH3jN3g/videos)|![](doc/youtube_icon.png) [Sham00k](https://www.youtube.com/channel/UCZXbWcv7fSZFTAZV4beckyw/videos)|
+|---|---|
+
+|![](doc/youtube_icon.png) [Collider videos](https://www.youtube.com/watch?v=A91P2qtPT54&list=PLayt6616lBclvOprvrC8qKGCO-mAhPRux)|![](doc/youtube_icon.png) [iFake](https://www.youtube.com/channel/UCC0lK2Zo2BMXX-k1Ks0r7dg/videos)|![](doc/youtube_icon.png) [NextFace](https://www.youtube.com/channel/UCFh3gL0a8BS21g-DHvXZEeQ/videos)|
+|---|---|---|
+
+|![](doc/youtube_icon.png) [Futuring Machine](https://www.youtube.com/channel/UCC5BbFxqLQgfnWPhprmQLVg)|![](doc/youtube_icon.png) [RepresentUS](https://www.youtube.com/channel/UCRzgK52MmetD9aG8pDOID3g)|![](doc/youtube_icon.png) [Corridor Crew](https://www.youtube.com/c/corridorcrew/videos)|
+|---|---|---|
+
+|![](doc/youtube_icon.png) [DeepFaker](https://www.youtube.com/channel/UCkHecfDTcSazNZSKPEhtPVQ)|![](doc/youtube_icon.png) [DeepFakes in movie](https://www.youtube.com/c/DeepFakesinmovie/videos)|
+|---|---|
+
+|![](doc/youtube_icon.png) [DeepFakeCreator](https://www.youtube.com/channel/UCkNFhcYNLQ5hr6A6lZ56mKA)|![](doc/youtube_icon.png) [Jarkan](https://www.youtube.com/user/Jarkancio/videos)|
+|---|---|
+
+</td></tr>
+
+<tr><td colspan=2 align="center">
+
+# What can I do using DeepFaceLab?
+
+</td></tr>
+<tr><td colspan=2 align="center">
+
+## Replace the face
+
+<img src="doc/replace_the_face.jpg" align="center">
+
+</td></tr>
+
+<tr><td colspan=2 align="center">
+
+## De-age the face
+
+</td></tr>
+
+<tr><td align="center" width="50%">
+
+<img src="doc/deage_0_1.jpg" align="center">
+
+</td>
+<td align="center" width="50%">
+
+<img src="doc/deage_0_2.jpg" align="center">
+
+</td></tr>
+
+<tr><td colspan=2 align="center">
+
+![](doc/youtube_icon.png) https://www.youtube.com/watch?v=Ddx5B-84ebo
+
+</td></tr>
+
+<tr><td colspan=2 align="center">
+
+## Replace the head
+
+</td></tr>
+
+
+<tr><td align="center" width="50%">
+
+<img src="doc/head_replace_0_1.jpg" align="center">
+
+</td>
+<td align="center" width="50%">
+
+<img src="doc/head_replace_0_2.jpg" align="center">
+
+</td></tr>
+
+<tr><td colspan=2 align="center">
+
+![](doc/youtube_icon.png) https://www.youtube.com/watch?v=xr5FHd0AdlQ
+
+</td></tr>
+
+<tr><td align="center" width="50%">
+
+<img src="doc/head_replace_1_1.jpg" align="center">
+
+</td>
+<td align="center" width="50%">
+
+<img src="doc/head_replace_1_2.jpg" align="center">
+
+</td></tr>
+
+<tr><td colspan=2 align="center">
+
+![](doc/youtube_icon.png) https://www.youtube.com/watch?v=RTjgkhMugVw
+
+</td></tr>
+
+<tr><td align="center" width="50%">
+
+<img src="doc/head_replace_2_1.jpg" align="center">
+
+</td>
+<td align="center" width="50%">
+
+<img src="doc/head_replace_2_2.jpg" align="center">
+
+</td></tr>
+
+<tr><td colspan=2  align="center">
+
+![](doc/youtube_icon.png) https://www.youtube.com/watch?v=R9f7WD0gKPo
+
+</td></tr>
+
+
+<tr><td colspan=2 align="center">
+
+## Manipulate politicians lips
+(voice replacement is not included!)
+(also requires a skill in video editors such as *Adobe After Effects* or *Davinci Resolve*)
+
+<img src="doc/political_speech2.jpg" align="center">
+
+![](doc/youtube_icon.png) https://www.youtube.com/watch?v=IvY-Abd2FfM
+
+<img src="doc/political_speech3.jpg" align="center">
+
+![](doc/youtube_icon.png) https://www.youtube.com/watch?v=ERQlaJ_czHU
+
+</td></tr>
+<tr><td colspan=2 align="center">
+
+# Deepfake native resolution progress
+
+</td></tr>
+<tr><td colspan=2 align="center">
+
+<img src="doc/deepfake_progress.png" align="center">
+
+</td></tr>
+<tr><td colspan=2 align="center">
+
+<img src="doc/make_everything_ok.png" align="center">
+
+Unfortunately, there is no "make everything ok" button in DeepFaceLab. You should spend time studying the workflow and growing your skills. A skill in programs such as *AfterEffects* or *Davinci Resolve* is also desirable.
+
+</td></tr>
+<tr><td colspan=2 align="center">
+
+## Mini tutorial
+
+<a href="https://www.youtube.com/watch?v=kOIMXt8KK8M">
+
+<img src="doc/mini_tutorial.jpg" align="center">
+
+</a>
+
+</td></tr>
+<tr><td colspan=2 align="center">
+
+## Releases
+
+</td></tr>
+
+<tr><td align="right">
+<a href="https://tinyurl.com/4vwvjuen">Windows (magnet link)</a>
+</td><td align="center">Last release. Use torrent client to download.</td></tr>
+
+<tr><td align="right">
+<a href="https://mega.nz/folder/Po0nGQrA#dbbttiNWojCt8jzD4xYaPw">Windows (Mega.nz)</a>
+</td><td align="center">Contains new and prev releases.</td></tr>
+
+<tr><td align="right">
+<a href="https://github.com/chervonij/DFL-Colab">Google Colab (github)</a>
+</td><td align="center">by @chervonij . You can train fakes for free using Google Colab.</td></tr>
+
+<tr><td align="right">
+<a href="https://github.com/nagadit/DeepFaceLab_Linux">Linux (github)</a>
+</td><td align="center">by @nagadit</td></tr>
+
+<tr><td align="right">
+<a href="https://github.com/elemantalcode/dfl">CentOS Linux (github)</a>
+</td><td align="center">May be outdated. By @elemantalcode</td></tr>
+
+</table>
+
+<table align="center" border="0">
+
+<tr><td colspan=2 align="center">
+
+## Links
+
+</td></tr>
+
+<tr><td colspan=2 align="center">
+
+### Guides and tutorials
+
+</td></tr>
+
+<tr><td align="right">
+<a href="https://mrdeepfakes.com/forums/thread-guide-deepfacelab-2-0-guide">DeepFaceLab guide</a>
+</td><td align="center">Main guide</td></tr>
+
+<tr><td align="right">
+<a href="https://mrdeepfakes.com/forums/thread-guide-deepfacelab-2-0-guide?pid=18459#pid18459">Faceset creation guide</a>
+</td><td align="center">How to create the right faceset</td></tr>
+
+<tr><td align="right">
+<a href="https://mrdeepfakes.com/forums/thread-guide-deepfacelab-google-colab-tutorial">Google Colab guide</a>
+</td><td align="center">Guide how to train the fake on Google Colab</td></tr>
+
+<tr><td align="right">
+<a href="https://mrdeepfakes.com/forums/thread-deepfacelab-2-0-compositing-in-davinci-resolve-vegas-pro-and-after-effects">Compositing</a>
+</td><td align="center">To achieve the highest quality, compose deepfake manually in video editors such as Davinci Resolve or Adobe AfterEffects</td></tr>
+
+<tr><td align="right">
+<a href="https://mrdeepfakes.com/forums/thread-deepfacelab-2-0-discussion-tips-suggestions">Discussion and suggestions</a>
+</td><td align="center"></td></tr>
+
+<tr><td colspan=2 align="center">
+
+### Supplementary material
+
+</td></tr>
+
+<tr><td align="right">
+<a href="https://mrdeepfakes.com/forums/forum-celebrity-facesets">Ready to work facesets</a>
+</td><td align="center">Celebrity facesets made by community</td></tr>
+
+<tr><td align="right">
+<a href="https://mrdeepfakes.com/forums/forum-trained-models">Pretrained models</a>
+</td><td align="center">Pretrained models made by community</td></tr>
+
+<tr><td colspan=2 align="center">
+
+### Communication groups
+
+</td></tr>
+
+<tr><td align="right">
+<a href="https://discord.gg/S2h7kPySQp">Discord</a>
+</td><td align="center">Official discord channel. English / Russian.</td></tr>
+
+<tr><td align="right">
+<a href="https://t.me/joinchat/ElkhqlgJ0I5HhdJyFar80w">Telegram group</a>
+</td><td align="center">Official telegram group. English / Russian. For anonymous communication. Don't forget to hide your phone number</td></tr>
+
+<tr><td align="right">
+<a href="https://mrdeepfakes.com/forums/forum-russian-community">Русский форум</a>
+</td><td align="center"></td></tr>
+
+<tr><td align="right">
+<a href="https://mrdeepfakes.com/forums/">mrdeepfakes</a>
+</td><td align="center">the biggest NSFW English community</td></tr>
+
+<tr><td align="right">
+<a href="https://www.reddit.com/r/DeepFakesSFW/new/">reddit r/DeepFakesSFW/</a>
+</td><td align="center">Post your deepfakes there !</td></tr>
+
+<tr><td align="right">
+<a href="https://www.reddit.com/r/RUdeepfakes/new/">reddit r/RUdeepfakes/</a>
+</td><td align="center">Постим русские дипфейки сюда !</td></tr>
+
+<tr><td align="right">
+QQ群1095077489
+</td><td align="center">中文交流QQ群，商务合作找群主</td></tr>
+
+<tr><td align="right">
+<a href="https://www.dfldata.xyz">dfldata.xyz</a>
+</td><td align="center">中文交流论坛，免费软件教程、模型、人脸数据</td></tr>
+
+<tr><td align="right">
+<a href="https://www.deepfaker.xyz/">deepfaker.xyz</a>
+</td><td align="center">中文学习站（非官方)</td></tr>
+
+<tr><td colspan=2 align="center">
+
+## Related works
+
+</td></tr>
+
+<tr><td align="right">
+<a href="https://github.com/iperov/DeepFaceLive">DeepFaceLive</a>
+</td><td align="center">Real-time face swap for PC streaming or video calls</td></tr>
+
+<tr><td align="right">
+<a href="https://github.com/neuralchen/SimSwap">neuralchen/SimSwap</a>
+</td><td align="center">Swapping face using ONE single photo 一张图免训练换脸</td></tr>
+
+<tr><td align="right">
+<a href="https://github.com/deepfakes/faceswap">deepfakes/faceswap</a>
+</td><td align="center">Something that was before DeepFaceLab and still remains in the past</td></tr>
+
+</td></tr>
+</table>
+
+<table align="center" border="0">
+
+<tr><td colspan=2 align="center">
+
+## How I can help the project?
+
+</td></tr>
+
+<tr><td colspan=2 align="center">
+
+### Sponsor deepfake research and DeepFaceLab development.
+
+</td></tr>
+
+<tr><td colspan=2 align="center">
+<a href="https://www.paypal.com/paypalme/DeepFaceLab">Donate via Paypal</a>
+</td></tr>
+
+<tr><td colspan=2 align="center">
+<a href="https://money.yandex.ru/to/41001142318065">Donate via Yandex.Money</a>
+</td></tr>
+
+<tr><td colspan=2 align="center">
+bitcoin:bc1qkhh7h0gwwhxgg6h6gpllfgstkd645fefrd5s6z
+</td></tr>
+
+<tr><td colspan=2 align="center">
+
+### Collect facesets
+
+</td></tr>
+
+<tr><td colspan=2 align="center">
+
+You can collect faceset of any celebrity that can be used in DeepFaceLab and share it <a href="https://mrdeepfakes.com/forums/forum-celebrity-facesets">in the community</a>
+</td></tr>
+
+<tr><td colspan=2 align="center">
+
+### Star this repo
+
+</td></tr>
+
+<tr><td colspan=2 align="center">
+
+Register github account and push "Star" button.
+
+</td></tr>
+
+</table>
+
+
+
+<table align="center" border="0">
+<tr><td colspan=2 align="center">
+
+## Meme zone
+
+</td></tr>
+
+<tr><td align="center" width="50%">
+
+<img src="doc/meme1.jpg" align="center">
+
+</td>
+
+<td align="center" width="50%">
+
+<img src="doc/meme2.jpg" align="center">
+
+</td></tr>
+
+<tr><td colspan=2>
+<img src="doc/meme3.jpg" align="center">
+</td></tr>
+
+<tr><td align="center" width="50%">
+
+## You don't need deepfake detector. You need to stop lying. 
+
+
+
+</td><td align="center" width="10%">
+
+<img src="https://i.imgur.com/z0e0xFB.jpg" align="center">
+
+V.I. Lenin
+</td></tr>
+
+<tr><td colspan=2 align="center">
+
+<sub>#deepfacelab #deepfakes #faceswap #face-swap #deep-learning #deeplearning #deep-neural-networks #deepface #deep-face-swap #fakeapp #fake-app #neural-networks #neural-nets #tensorflow #cuda #nvidia</sub>
+
+</td></tr>
+
+
+
+</table>

XSegEditor/QCursorDB.py

@@ -0,0 +1,10 @@
+from PyQt5.QtCore import *
+from PyQt5.QtGui import *
+from PyQt5.QtWidgets import *
+                                       
+class QCursorDB():
+    @staticmethod
+    def initialize(cursor_path):
+        QCursorDB.cross_red = QCursor ( QPixmap ( str(cursor_path / 'cross_red.png') ) )
+        QCursorDB.cross_green = QCursor ( QPixmap ( str(cursor_path / 'cross_green.png') ) )
+        QCursorDB.cross_blue = QCursor ( QPixmap ( str(cursor_path / 'cross_blue.png') ) )

XSegEditor/QIconDB.py

@@ -0,0 +1,26 @@
+from PyQt5.QtCore import *
+from PyQt5.QtGui import *
+from PyQt5.QtWidgets import *
+
+
+class QIconDB():
+    @staticmethod
+    def initialize(icon_path):
+        QIconDB.app_icon         = QIcon ( str(icon_path / 'app_icon.png') )
+        QIconDB.delete_poly      = QIcon ( str(icon_path / 'delete_poly.png') )
+        QIconDB.undo_pt          = QIcon ( str(icon_path / 'undo_pt.png') )
+        QIconDB.redo_pt          = QIcon ( str(icon_path / 'redo_pt.png') )
+        QIconDB.poly_color_red   = QIcon ( str(icon_path / 'poly_color_red.png') )
+        QIconDB.poly_color_green = QIcon ( str(icon_path / 'poly_color_green.png') )
+        QIconDB.poly_color_blue  = QIcon ( str(icon_path / 'poly_color_blue.png') )
+        QIconDB.poly_type_include = QIcon ( str(icon_path / 'poly_type_include.png') )
+        QIconDB.poly_type_exclude = QIcon ( str(icon_path / 'poly_type_exclude.png') )
+        QIconDB.left  = QIcon ( str(icon_path / 'left.png') )
+        QIconDB.right = QIcon ( str(icon_path / 'right.png') )
+        QIconDB.trashcan = QIcon ( str(icon_path / 'trashcan.png') )
+        QIconDB.pt_edit_mode = QIcon ( str(icon_path / 'pt_edit_mode.png') )
+        QIconDB.view_lock_center = QIcon ( str(icon_path / 'view_lock_center.png') )
+        QIconDB.view_baked = QIcon ( str(icon_path / 'view_baked.png') )
+        QIconDB.view_xseg = QIcon ( str(icon_path / 'view_xseg.png') )
+        QIconDB.view_xseg_overlay = QIcon ( str(icon_path / 'view_xseg_overlay.png') )
+        

XSegEditor/QImageDB.py

@@ -0,0 +1,8 @@
+from PyQt5.QtCore import *
+from PyQt5.QtGui import *
+from PyQt5.QtWidgets import *
+
+class QImageDB():
+    @staticmethod
+    def initialize(image_path):
+        QImageDB.intro = QImage ( str(image_path / 'intro.png') )

XSegEditor/QStringDB.py

@@ -0,0 +1,102 @@
+from localization import system_language
+
+
+class QStringDB():
+    
+    @staticmethod
+    def initialize():
+        lang = system_language
+        
+        if lang not in ['en','ru','zh']:
+            lang = 'en'
+        
+        QStringDB.btn_poly_color_red_tip = {    'en' : 'Poly color scheme red',
+                                                'ru' : 'Красная цветовая схема полигонов',
+                                                'zh' : '选区配色方案红色',
+                                           }[lang]
+                                           
+        QStringDB.btn_poly_color_green_tip = {  'en' : 'Poly color scheme green',
+                                                'ru' : 'Зелёная цветовая схема полигонов',
+                                                'zh' : '选区配色方案绿色',
+                                           }[lang]
+                                           
+        QStringDB.btn_poly_color_blue_tip = {   'en' : 'Poly color scheme blue',
+                                                'ru' : 'Синяя цветовая схема полигонов',
+                                                'zh' : '选区配色方案蓝色',
+                                           }[lang]
+                                           
+        QStringDB.btn_view_baked_mask_tip = {   'en' : 'View baked mask',
+                                                'ru' : 'Посмотреть запечёную маску',
+                                                'zh' : '查看遮罩通道',
+                                           }[lang]
+                                           
+        QStringDB.btn_view_xseg_mask_tip =  {   'en' : 'View trained XSeg mask',
+                                                'ru' : 'Посмотреть тренированную XSeg маску',
+                                                'zh' : '查看导入后的XSeg遮罩',
+                                            }[lang]
+                                            
+        QStringDB.btn_view_xseg_overlay_mask_tip =  {   'en' : 'View trained XSeg mask overlay face',
+                                                        'ru' : 'Посмотреть тренированную XSeg маску поверх лица',
+                                                        'zh' : '查看导入后的XSeg遮罩于脸上方',
+                                                    }[lang]
+                                           
+        QStringDB.btn_poly_type_include_tip = { 'en' : 'Poly include mode',
+                                                'ru' : 'Режим полигонов - включение',
+                                                'zh' : '包含选区模式',
+                                           }[lang]
+                                           
+        QStringDB.btn_poly_type_exclude_tip = { 'en' : 'Poly exclude mode',
+                                                'ru' : 'Режим полигонов - исключение',
+                                                'zh' : '排除选区模式',
+                                           }[lang]        
+                                           
+        QStringDB.btn_undo_pt_tip = {   'en' : 'Undo point',
+                                        'ru' : 'Отменить точку',
+                                        'zh' : '撤消点',
+                                    }[lang]      
+                                     
+        QStringDB.btn_redo_pt_tip = {   'en' : 'Redo point',
+                                        'ru' : 'Повторить точку',
+                                        'zh' : '重做点',
+                                     }[lang]      
+                                      
+        QStringDB.btn_delete_poly_tip = {   'en' : 'Delete poly',
+                                            'ru' : 'Удалить полигон',
+                                            'zh' : '删除选区',
+                                           }[lang]     
+                                              
+        QStringDB.btn_pt_edit_mode_tip = {  'en' : 'Add/delete point mode ( HOLD CTRL )',
+                                            'ru' : 'Режим добавления/удаления точек ( удерживайте CTRL )',
+                                            'zh' : '点加/删除模式 ( 按住CTRL )',
+                                           }[lang]    
+                                           
+        QStringDB.btn_view_lock_center_tip = { 'en' : 'Lock cursor at the center ( HOLD SHIFT )',
+                                               'ru' : 'Заблокировать курсор в центре ( удерживайте SHIFT )',
+                                               'zh' : '将光标锁定在中心 ( 按住SHIFT )',
+                                             }[lang]                    
+                                        
+                                           
+        QStringDB.btn_prev_image_tip = {    'en' : 'Save and Prev image\nHold SHIFT : accelerate\nHold CTRL : skip non masked\n',
+                                            'ru' : 'Сохранить и предыдущее изображение\nУдерживать SHIFT : ускорить\nУдерживать CTRL : пропустить неразмеченные\n',
+                                            'zh' : '保存并转到上一张图片\n按住SHIFT : 加快\n按住CTRL : 跳过未标记的\n',
+                                           }[lang]   
+        QStringDB.btn_next_image_tip = {    'en' : 'Save and Next image\nHold SHIFT : accelerate\nHold CTRL : skip non masked\n',
+                                            'ru' : 'Сохранить и следующее изображение\nУдерживать SHIFT : ускорить\nУдерживать CTRL : пропустить неразмеченные\n',
+                                            'zh' : '保存并转到下一张图片\n按住SHIFT : 加快\n按住CTRL : 跳过未标记的\n',
+                                           }[lang]  
+        
+        QStringDB.btn_delete_image_tip = {  'en' : 'Move to _trash and Next image\n',
+                                            'ru' : 'Переместить в _trash и следующее изображение\n',
+                                            'zh' : '移至_trash，转到下一张图片 ',
+                                           }[lang]  
+                                           
+        QStringDB.loading_tip = {'en' : 'Loading',
+                                 'ru' : 'Загрузка',
+                                 'zh' : '正在载入',
+                                }[lang]   
+                                
+        QStringDB.labeled_tip = {'en' : 'labeled',
+                                 'ru' : 'размечено',
+                                 'zh' : '标记的',
+                                }[lang]   
+                                           

XSegEditor/XSegEditor - Copy.py

@@ -0,0 +1,1522 @@
+import json
+import multiprocessing
+import os
+import pickle
+import sys
+import tempfile
+import time
+import traceback
+from enum import IntEnum
+from types import SimpleNamespace as sn
+
+import cv2
+import numpy as np
+import numpy.linalg as npla
+from PyQt5.QtCore import *
+from PyQt5.QtGui import *
+from PyQt5.QtWidgets import *
+
+from core import imagelib, pathex
+from core.cv2ex import *
+from core.imagelib import SegIEPoly, SegIEPolys, SegIEPolyType, sd
+from core.qtex import *
+from DFLIMG import *
+from localization import StringsDB, system_language
+from samplelib import PackedFaceset
+
+from .QCursorDB import QCursorDB
+from .QIconDB import QIconDB
+from .QStringDB import QStringDB
+from .QImageDB import QImageDB
+
+class OpMode(IntEnum):
+    NONE = 0
+    DRAW_PTS = 1
+    EDIT_PTS = 2
+    VIEW_BAKED = 3
+    VIEW_XSEG_MASK = 4
+    VIEW_XSEG_OVERLAY_MASK = 5
+
+class PTEditMode(IntEnum):
+    MOVE = 0
+    ADD_DEL = 1
+
+class DragType(IntEnum):
+    NONE = 0
+    IMAGE_LOOK = 1
+    POLY_PT = 2
+
+class ViewLock(IntEnum):
+    NONE = 0
+    CENTER = 1
+
+class QUIConfig():
+    @staticmethod
+    def initialize(icon_size = 48, icon_spacer_size=16, preview_bar_icon_size=64):
+        QUIConfig.icon_q_size = QSize(icon_size, icon_size)
+        QUIConfig.icon_spacer_q_size = QSize(icon_spacer_size, icon_spacer_size)
+        QUIConfig.preview_bar_icon_q_size = QSize(preview_bar_icon_size, preview_bar_icon_size)
+
+class ImagePreviewSequenceBar(QFrame):
+    def __init__(self, preview_images_count, icon_size):
+        super().__init__()
+        self.preview_images_count = preview_images_count = max(1, preview_images_count + (preview_images_count % 2 -1) )
+
+        self.icon_size = icon_size
+
+        black_q_img = QImage(np.zeros( (icon_size,icon_size,3) ).data, icon_size, icon_size, 3*icon_size, QImage.Format_RGB888)
+        self.black_q_pixmap = QPixmap.fromImage(black_q_img)
+
+        self.image_containers = [ QLabel() for i in range(preview_images_count)]
+
+        main_frame_l_cont_hl = QGridLayout()
+        main_frame_l_cont_hl.setContentsMargins(0,0,0,0)
+        #main_frame_l_cont_hl.setSpacing(0)
+
+
+
+        for i in range(len(self.image_containers)):
+            q_label = self.image_containers[i]
+            q_label.setScaledContents(True)
+            if i == preview_images_count//2:
+                q_label.setMinimumSize(icon_size+16, icon_size+16 )
+                q_label.setMaximumSize(icon_size+16, icon_size+16 )
+            else:
+                q_label.setMinimumSize(icon_size, icon_size )
+                q_label.setMaximumSize(icon_size, icon_size )
+                opacity_effect = QGraphicsOpacityEffect()
+                opacity_effect.setOpacity(0.5)
+                q_label.setGraphicsEffect(opacity_effect)
+
+            q_label.setSizePolicy (QSizePolicy.Fixed, QSizePolicy.Fixed)
+
+            main_frame_l_cont_hl.addWidget (q_label, 0, i)
+
+        self.setLayout(main_frame_l_cont_hl)
+
+        self.prev_img_conts = self.image_containers[(preview_images_count//2) -1::-1]
+        self.next_img_conts = self.image_containers[preview_images_count//2:]
+
+        self.update_images()
+
+    def get_preview_images_count(self):
+        return self.preview_images_count
+
+    def update_images(self, prev_imgs=None, next_imgs=None):
+        # Fix arrays
+        if prev_imgs is None:
+            prev_imgs = []
+        prev_img_conts_len = len(self.prev_img_conts)
+        prev_q_imgs_len = len(prev_imgs)
+        if prev_q_imgs_len < prev_img_conts_len:
+            for i in range ( prev_img_conts_len - prev_q_imgs_len ):
+                prev_imgs.append(None)
+        elif prev_q_imgs_len > prev_img_conts_len:
+            prev_imgs = prev_imgs[:prev_img_conts_len]
+
+        if next_imgs is None:
+            next_imgs = []
+        next_img_conts_len = len(self.next_img_conts)
+        next_q_imgs_len = len(next_imgs)
+        if next_q_imgs_len < next_img_conts_len:
+            for i in range ( next_img_conts_len - next_q_imgs_len ):
+                next_imgs.append(None)
+        elif next_q_imgs_len > next_img_conts_len:
+            next_imgs = next_imgs[:next_img_conts_len]
+
+        for i,img in enumerate(prev_imgs):
+            self.prev_img_conts[i].setPixmap( QPixmap.fromImage( QImage_from_np(img) ) if img is not None else self.black_q_pixmap )
+
+        for i,img in enumerate(next_imgs):
+            self.next_img_conts[i].setPixmap( QPixmap.fromImage( QImage_from_np(img) ) if img is not None else self.black_q_pixmap )
+
+class ColorScheme():
+    def __init__(self, unselected_color, selected_color, outline_color, outline_width, pt_outline_color, cross_cursor):
+        self.poly_unselected_brush = QBrush(unselected_color)
+        self.poly_selected_brush = QBrush(selected_color)
+
+        self.poly_outline_solid_pen = QPen(outline_color, outline_width, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)
+        self.poly_outline_dot_pen = QPen(outline_color, outline_width, Qt.DotLine, Qt.RoundCap, Qt.RoundJoin)
+
+        self.pt_outline_pen = QPen(pt_outline_color)
+        self.cross_cursor = cross_cursor
+
+class CanvasConfig():
+
+    def __init__(self,
+                 pt_radius=4,
+                 pt_select_radius=8,
+                 color_schemes=None,
+                 **kwargs):
+        self.pt_radius = pt_radius
+        self.pt_select_radius = pt_select_radius
+
+        if color_schemes is None:
+            color_schemes = [
+                    ColorScheme( QColor(192,0,0,alpha=0), QColor(192,0,0,alpha=72), QColor(192,0,0), 2, QColor(255,255,255), QCursorDB.cross_red ),
+                    ColorScheme( QColor(0,192,0,alpha=0), QColor(0,192,0,alpha=72), QColor(0,192,0), 2, QColor(255,255,255), QCursorDB.cross_green ),
+                    ColorScheme( QColor(0,0,192,alpha=0), QColor(0,0,192,alpha=72), QColor(0,0,192), 2, QColor(255,255,255), QCursorDB.cross_blue ),
+                    ]
+        self.color_schemes = color_schemes
+
+class QCanvasControlsLeftBar(QFrame):
+
+    def __init__(self):
+        super().__init__()
+        #==============================================
+        btn_poly_type_include = QToolButton()
+        self.btn_poly_type_include_act = QActionEx( QIconDB.poly_type_include, QStringDB.btn_poly_type_include_tip, shortcut='Q', shortcut_in_tooltip=True, is_checkable=True)
+        btn_poly_type_include.setDefaultAction(self.btn_poly_type_include_act)
+        btn_poly_type_include.setIconSize(QUIConfig.icon_q_size)
+
+        btn_poly_type_exclude = QToolButton()
+        self.btn_poly_type_exclude_act = QActionEx( QIconDB.poly_type_exclude, QStringDB.btn_poly_type_exclude_tip, shortcut='W', shortcut_in_tooltip=True, is_checkable=True)
+        btn_poly_type_exclude.setDefaultAction(self.btn_poly_type_exclude_act)
+        btn_poly_type_exclude.setIconSize(QUIConfig.icon_q_size)
+
+        self.btn_poly_type_act_grp = QActionGroup (self)
+        self.btn_poly_type_act_grp.addAction(self.btn_poly_type_include_act)
+        self.btn_poly_type_act_grp.addAction(self.btn_poly_type_exclude_act)
+        self.btn_poly_type_act_grp.setExclusive(True)
+        #==============================================
+        btn_undo_pt = QToolButton()
+        self.btn_undo_pt_act = QActionEx( QIconDB.undo_pt, QStringDB.btn_undo_pt_tip, shortcut='Ctrl+Z', shortcut_in_tooltip=True, is_auto_repeat=True)
+        btn_undo_pt.setDefaultAction(self.btn_undo_pt_act)
+        btn_undo_pt.setIconSize(QUIConfig.icon_q_size)
+
+        btn_redo_pt = QToolButton()
+        self.btn_redo_pt_act = QActionEx( QIconDB.redo_pt, QStringDB.btn_redo_pt_tip, shortcut='Ctrl+Shift+Z',  shortcut_in_tooltip=True, is_auto_repeat=True)
+        btn_redo_pt.setDefaultAction(self.btn_redo_pt_act)
+        btn_redo_pt.setIconSize(QUIConfig.icon_q_size)
+
+        btn_delete_poly = QToolButton()
+        self.btn_delete_poly_act = QActionEx( QIconDB.delete_poly, QStringDB.btn_delete_poly_tip, shortcut='Delete', shortcut_in_tooltip=True)
+        btn_delete_poly.setDefaultAction(self.btn_delete_poly_act)
+        btn_delete_poly.setIconSize(QUIConfig.icon_q_size)
+        #==============================================
+        btn_pt_edit_mode = QToolButton()
+        self.btn_pt_edit_mode_act = QActionEx( QIconDB.pt_edit_mode, QStringDB.btn_pt_edit_mode_tip, shortcut_in_tooltip=True, is_checkable=True)
+        btn_pt_edit_mode.setDefaultAction(self.btn_pt_edit_mode_act)
+        btn_pt_edit_mode.setIconSize(QUIConfig.icon_q_size)
+        #==============================================
+
+        controls_bar_frame2_l = QVBoxLayout()
+        controls_bar_frame2_l.addWidget ( btn_poly_type_include )
+        controls_bar_frame2_l.addWidget ( btn_poly_type_exclude )
+        controls_bar_frame2 = QFrame()
+        controls_bar_frame2.setFrameShape(QFrame.StyledPanel)
+        controls_bar_frame2.setSizePolicy (QSizePolicy.Fixed, QSizePolicy.Fixed)
+        controls_bar_frame2.setLayout(controls_bar_frame2_l)
+
+        controls_bar_frame3_l = QVBoxLayout()
+        controls_bar_frame3_l.addWidget ( btn_undo_pt )
+        controls_bar_frame3_l.addWidget ( btn_redo_pt )
+        controls_bar_frame3_l.addWidget ( btn_delete_poly )
+        controls_bar_frame3 = QFrame()
+        controls_bar_frame3.setFrameShape(QFrame.StyledPanel)
+        controls_bar_frame3.setSizePolicy (QSizePolicy.Fixed, QSizePolicy.Fixed)
+        controls_bar_frame3.setLayout(controls_bar_frame3_l)
+
+        controls_bar_frame4_l = QVBoxLayout()
+        controls_bar_frame4_l.addWidget ( btn_pt_edit_mode )
+        controls_bar_frame4 = QFrame()
+        controls_bar_frame4.setFrameShape(QFrame.StyledPanel)
+        controls_bar_frame4.setSizePolicy (QSizePolicy.Fixed, QSizePolicy.Fixed)
+        controls_bar_frame4.setLayout(controls_bar_frame4_l)
+
+        btn_view_lock_center = QToolButton()
+        self.btn_view_lock_center_act = QActionEx( QIconDB.view_lock_center, QStringDB.btn_view_lock_center_tip, shortcut_in_tooltip=True, is_checkable=True)
+        btn_view_lock_center.setDefaultAction(self.btn_view_lock_center_act)
+        btn_view_lock_center.setIconSize(QUIConfig.icon_q_size)
+        
+        controls_bar_frame5_l = QVBoxLayout()
+        controls_bar_frame5_l.addWidget ( btn_view_lock_center )
+        controls_bar_frame5 = QFrame()
+        controls_bar_frame5.setFrameShape(QFrame.StyledPanel)
+        controls_bar_frame5.setSizePolicy (QSizePolicy.Fixed, QSizePolicy.Fixed)
+        controls_bar_frame5.setLayout(controls_bar_frame5_l)
+        
+        
+        controls_bar_l = QVBoxLayout()
+        controls_bar_l.setContentsMargins(0,0,0,0)
+        controls_bar_l.addWidget(controls_bar_frame2)
+        controls_bar_l.addWidget(controls_bar_frame3)
+        controls_bar_l.addWidget(controls_bar_frame4)        
+        controls_bar_l.addWidget(controls_bar_frame5)
+        
+        self.setSizePolicy ( QSizePolicy.Fixed, QSizePolicy.Expanding )
+        self.setLayout(controls_bar_l)
+
+class QCanvasControlsRightBar(QFrame):
+
+    def __init__(self):
+        super().__init__()
+        #==============================================
+        btn_poly_color_red = QToolButton()
+        self.btn_poly_color_red_act = QActionEx( QIconDB.poly_color_red, QStringDB.btn_poly_color_red_tip, shortcut='1', shortcut_in_tooltip=True, is_checkable=True)
+        btn_poly_color_red.setDefaultAction(self.btn_poly_color_red_act)
+        btn_poly_color_red.setIconSize(QUIConfig.icon_q_size)
+
+        btn_poly_color_green = QToolButton()
+        self.btn_poly_color_green_act = QActionEx( QIconDB.poly_color_green, QStringDB.btn_poly_color_green_tip, shortcut='2', shortcut_in_tooltip=True, is_checkable=True)
+        btn_poly_color_green.setDefaultAction(self.btn_poly_color_green_act)
+        btn_poly_color_green.setIconSize(QUIConfig.icon_q_size)
+
+        btn_poly_color_blue = QToolButton()
+        self.btn_poly_color_blue_act = QActionEx( QIconDB.poly_color_blue, QStringDB.btn_poly_color_blue_tip, shortcut='3', shortcut_in_tooltip=True, is_checkable=True)
+        btn_poly_color_blue.setDefaultAction(self.btn_poly_color_blue_act)
+        btn_poly_color_blue.setIconSize(QUIConfig.icon_q_size)
+
+        btn_view_baked_mask = QToolButton()
+        self.btn_view_baked_mask_act = QActionEx( QIconDB.view_baked, QStringDB.btn_view_baked_mask_tip, shortcut='4', shortcut_in_tooltip=True, is_checkable=True)
+        btn_view_baked_mask.setDefaultAction(self.btn_view_baked_mask_act)
+        btn_view_baked_mask.setIconSize(QUIConfig.icon_q_size)
+
+        btn_view_xseg_mask = QToolButton()
+        self.btn_view_xseg_mask_act = QActionEx( QIconDB.view_xseg, QStringDB.btn_view_xseg_mask_tip, shortcut='5', shortcut_in_tooltip=True, is_checkable=True)
+        btn_view_xseg_mask.setDefaultAction(self.btn_view_xseg_mask_act)
+        btn_view_xseg_mask.setIconSize(QUIConfig.icon_q_size)
+
+        btn_view_xseg_overlay_mask = QToolButton()
+        self.btn_view_xseg_overlay_mask_act = QActionEx( QIconDB.view_xseg_overlay, QStringDB.btn_view_xseg_overlay_mask_tip, shortcut='6', shortcut_in_tooltip=True, is_checkable=True)
+        btn_view_xseg_overlay_mask.setDefaultAction(self.btn_view_xseg_overlay_mask_act)
+        btn_view_xseg_overlay_mask.setIconSize(QUIConfig.icon_q_size)
+
+        self.btn_poly_color_act_grp = QActionGroup (self)
+        self.btn_poly_color_act_grp.addAction(self.btn_poly_color_red_act)
+        self.btn_poly_color_act_grp.addAction(self.btn_poly_color_green_act)
+        self.btn_poly_color_act_grp.addAction(self.btn_poly_color_blue_act)
+        self.btn_poly_color_act_grp.addAction(self.btn_view_baked_mask_act)
+        self.btn_poly_color_act_grp.addAction(self.btn_view_xseg_mask_act)
+        self.btn_poly_color_act_grp.addAction(self.btn_view_xseg_overlay_mask_act)
+        self.btn_poly_color_act_grp.setExclusive(True)
+        #==============================================
+        
+        btn_xseg_to_poly = QToolButton()
+        self.btn_xseg_to_poly_act = QActionEx( QIconDB.view_lock_center, QStringDB.btn_view_lock_center_tip, shortcut_in_tooltip=True, is_checkable=False)
+        btn_xseg_to_poly.setDefaultAction(self.btn_xseg_to_poly_act)
+        btn_xseg_to_poly.setIconSize(QUIConfig.icon_q_size)
+        
+        controls_bar_frame1_l = QVBoxLayout()
+        controls_bar_frame1_l.addWidget ( btn_poly_color_red )
+        controls_bar_frame1_l.addWidget ( btn_poly_color_green )
+        controls_bar_frame1_l.addWidget ( btn_poly_color_blue )
+        controls_bar_frame1_l.addWidget ( btn_view_baked_mask )
+        controls_bar_frame1_l.addWidget ( btn_view_xseg_mask )
+        controls_bar_frame1_l.addWidget ( btn_view_xseg_overlay_mask )
+        controls_bar_frame1 = QFrame()
+        controls_bar_frame1.setFrameShape(QFrame.StyledPanel)
+        controls_bar_frame1.setSizePolicy (QSizePolicy.Fixed, QSizePolicy.Fixed)
+        controls_bar_frame1.setLayout(controls_bar_frame1_l)
+
+        controls_bar_frame2_l = QVBoxLayout()
+        controls_bar_frame2_l.addWidget ( btn_xseg_to_poly )
+        controls_bar_frame2 = QFrame()
+        controls_bar_frame2.setFrameShape(QFrame.StyledPanel)
+        controls_bar_frame2.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+        controls_bar_frame2.setLayout(controls_bar_frame2_l)
+
+        controls_bar_l = QVBoxLayout()
+        controls_bar_l.setContentsMargins(0,0,0,0)
+        controls_bar_l.addWidget(controls_bar_frame1)
+        controls_bar_l.addWidget(controls_bar_frame2)
+        
+        self.setSizePolicy ( QSizePolicy.Fixed, QSizePolicy.Expanding )
+        self.setLayout(controls_bar_l)
+
+class QCanvasOperator(QWidget):
+    def __init__(self, cbar):
+        super().__init__()
+        self.cbar = cbar
+
+        self.set_cbar_disabled()
+
+        self.cbar.btn_poly_color_red_act.triggered.connect ( lambda : self.set_color_scheme_id(0) )
+        self.cbar.btn_poly_color_green_act.triggered.connect ( lambda : self.set_color_scheme_id(1) )
+        self.cbar.btn_poly_color_blue_act.triggered.connect ( lambda : self.set_color_scheme_id(2) )
+        self.cbar.btn_view_baked_mask_act.toggled.connect ( lambda : self.set_op_mode(OpMode.VIEW_BAKED) )
+        self.cbar.btn_view_xseg_mask_act.toggled.connect ( self.set_view_xseg_mask )
+        self.cbar.btn_view_xseg_overlay_mask_act.toggled.connect ( self.set_view_xseg_overlay_mask )
+
+        self.cbar.btn_poly_type_include_act.triggered.connect ( lambda : self.set_poly_include_type(SegIEPolyType.INCLUDE) )
+        self.cbar.btn_poly_type_exclude_act.triggered.connect ( lambda : self.set_poly_include_type(SegIEPolyType.EXCLUDE) )
+
+        self.cbar.btn_undo_pt_act.triggered.connect ( lambda : self.action_undo_pt() )
+        self.cbar.btn_redo_pt_act.triggered.connect ( lambda : self.action_redo_pt() )
+
+        self.cbar.btn_delete_poly_act.triggered.connect ( lambda : self.action_delete_poly() )
+
+        self.cbar.btn_pt_edit_mode_act.toggled.connect ( lambda is_checked: self.set_pt_edit_mode( PTEditMode.ADD_DEL if is_checked else PTEditMode.MOVE ) )
+        self.cbar.btn_view_lock_center_act.toggled.connect ( lambda is_checked: self.set_view_lock( ViewLock.CENTER if is_checked else ViewLock.NONE ) )
+
+        self.cbar.btn_xseg_to_poly_act.triggered.connect ( lambda : self.action_xseg_to_poly() )
+
+
+        self.mouse_in_widget = False
+
+        QXMainWindow.inst.add_keyPressEvent_listener ( self.on_keyPressEvent )
+        QXMainWindow.inst.add_keyReleaseEvent_listener ( self.on_keyReleaseEvent )
+
+        self.qp = QPainter()
+        self.initialized = False
+        self.last_state = None
+
+    def initialize(self, img, img_look_pt=None, view_scale=None, ie_polys=None, xseg_mask=None, canvas_config=None ):
+        self.img = img
+        q_img = self.q_img = QImage_from_np(img)
+        self.img_pixmap = QPixmap.fromImage(q_img)
+
+        self.xseg_mask_in = imagelib.normalize_channels(xseg_mask, 1)
+        self.xseg_mask_pixmap = None
+        self.xseg_overlay_mask_pixmap = None
+        
+        if xseg_mask is not None:
+            h,w,c = img.shape
+            xseg_mask = cv2.resize(xseg_mask, (w,h), cv2.INTER_CUBIC)
+            xseg_mask = imagelib.normalize_channels(xseg_mask, 1)
+            xseg_img = img.astype(np.float32)/255.0
+            xseg_overlay_mask = xseg_img*(1-xseg_mask)*0.5 + xseg_img*xseg_mask
+            xseg_overlay_mask = np.clip(xseg_overlay_mask*255, 0, 255).astype(np.uint8)
+            xseg_mask = np.clip(xseg_mask*255, 0, 255).astype(np.uint8)
+            self.xseg_mask_pixmap = QPixmap.fromImage(QImage_from_np(xseg_mask))
+            self.xseg_overlay_mask_pixmap = QPixmap.fromImage(QImage_from_np(xseg_overlay_mask))
+
+        self.img_size = QSize_to_np (self.img_pixmap.size())
+
+        self.img_look_pt = img_look_pt
+        self.view_scale = view_scale
+
+        if ie_polys is None:
+            ie_polys = SegIEPolys()
+        self.ie_polys = ie_polys
+
+        if canvas_config is None:
+            canvas_config = CanvasConfig()
+        self.canvas_config = canvas_config
+
+        # UI init
+        self.set_cbar_disabled()
+        self.cbar.btn_poly_color_act_grp.setDisabled(False)
+        self.cbar.btn_poly_type_act_grp.setDisabled(False)
+
+        # Initial vars
+        self.current_cursor = None
+        self.mouse_hull_poly = None
+        self.mouse_wire_poly = None
+        self.drag_type = DragType.NONE
+        self.mouse_cli_pt = np.zeros((2,), np.float32 )
+
+        # Initial state
+        self.set_op_mode(OpMode.NONE)
+        self.set_color_scheme_id(1)
+        self.set_poly_include_type(SegIEPolyType.INCLUDE)
+        self.set_pt_edit_mode(PTEditMode.MOVE)
+        self.set_view_lock(ViewLock.NONE)
+
+        # Apply last state
+        if self.last_state is not None:
+            self.set_color_scheme_id(self.last_state.color_scheme_id)
+            if self.last_state.op_mode is not None:
+                self.set_op_mode(self.last_state.op_mode)
+
+        self.initialized = True
+
+        self.setMouseTracking(True)
+        self.update_cursor()
+        self.update()
+
+
+    def finalize(self):
+        if self.initialized:
+            if self.op_mode == OpMode.DRAW_PTS:
+                self.set_op_mode(OpMode.EDIT_PTS)
+
+            self.last_state = sn(op_mode = self.op_mode if self.op_mode in [OpMode.VIEW_BAKED, OpMode.VIEW_XSEG_MASK, OpMode.VIEW_XSEG_OVERLAY_MASK] else None,
+                                 color_scheme_id = self.color_scheme_id,
+                               )
+
+            self.img_pixmap = None
+            self.update_cursor(is_finalize=True)
+            self.setMouseTracking(False)
+            self.setFocusPolicy(Qt.NoFocus)
+            self.set_cbar_disabled()
+            self.initialized = False
+            self.update()
+
+    # ====================================================================================
+    # ====================================================================================
+    # ====================================== GETTERS =====================================
+    # ====================================================================================
+    # ====================================================================================
+
+    def is_initialized(self):
+        return self.initialized
+
+    def get_ie_polys(self):
+        return self.ie_polys
+
+    def get_cli_center_pt(self):
+        return np.round(QSize_to_np(self.size())/2.0)
+
+    def get_img_look_pt(self):
+        img_look_pt = self.img_look_pt
+        if img_look_pt is None:
+            img_look_pt = self.img_size / 2
+        return img_look_pt
+
+    def get_view_scale(self):
+        view_scale = self.view_scale
+        if view_scale is None:
+            # Calc as scale to fit
+            min_cli_size = np.min(QSize_to_np(self.size()))
+            max_img_size = np.max(self.img_size)
+            view_scale =  min_cli_size / max_img_size
+
+        return view_scale
+
+    def get_current_color_scheme(self):
+        return self.canvas_config.color_schemes[self.color_scheme_id]
+
+    def get_poly_pt_id_under_pt(self, poly, cli_pt):
+        w = np.argwhere ( npla.norm ( cli_pt - self.img_to_cli_pt( poly.get_pts() ), axis=1 )  <= self.canvas_config.pt_select_radius )
+        return None if len(w) == 0 else w[-1][0]
+
+    def get_poly_edge_id_pt_under_pt(self, poly, cli_pt):
+        cli_pts = self.img_to_cli_pt(poly.get_pts())
+        if len(cli_pts) >= 3:
+            edge_dists, projs = sd.dist_to_edges(cli_pts, cli_pt, is_closed=True)
+            edge_id = np.argmin(edge_dists)
+            dist = edge_dists[edge_id]
+            pt = projs[edge_id]
+            if dist <= self.canvas_config.pt_select_radius:
+                return edge_id, pt
+        return None, None
+
+    def get_poly_by_pt_near_wire(self, cli_pt):
+        pt_select_radius = self.canvas_config.pt_select_radius
+
+        for poly in reversed(self.ie_polys.get_polys()):
+            pts = poly.get_pts()
+            if len(pts) >= 3:
+                cli_pts = self.img_to_cli_pt(pts)
+
+                edge_dists, _ = sd.dist_to_edges(cli_pts, cli_pt, is_closed=True)
+
+                if np.min(edge_dists) <= pt_select_radius or \
+                   any( npla.norm ( cli_pt - cli_pts, axis=1 ) <= pt_select_radius ):
+                    return poly
+        return None
+
+    def get_poly_by_pt_in_hull(self, cli_pos):
+        img_pos = self.cli_to_img_pt(cli_pos)
+
+        for poly in reversed(self.ie_polys.get_polys()):
+            pts = poly.get_pts()
+            if len(pts) >= 3:
+                if cv2.pointPolygonTest( pts, tuple(img_pos), False) >= 0:
+                    return poly
+
+        return None
+
+    def img_to_cli_pt(self, p):
+        return (p - self.get_img_look_pt()) * self.get_view_scale() + self.get_cli_center_pt()# QSize_to_np(self.size())/2.0
+
+    def cli_to_img_pt(self, p):
+        return (p - self.get_cli_center_pt() ) / self.get_view_scale() + self.get_img_look_pt()
+
+    def img_to_cli_rect(self, rect):
+        tl = QPoint_to_np(rect.topLeft())
+        xy = self.img_to_cli_pt(tl)
+        xy2 = self.img_to_cli_pt(tl + QSize_to_np(rect.size()) ) - xy
+        return QRect ( *xy.astype(np.int), *xy2.astype(np.int) )
+
+    # ====================================================================================
+    # ====================================================================================
+    # ====================================== SETTERS =====================================
+    # ====================================================================================
+    # ====================================================================================
+    def set_op_mode(self, op_mode, op_poly=None):
+        if not hasattr(self,'op_mode'):
+            self.op_mode = None
+            self.op_poly = None
+
+        if self.op_mode != op_mode:
+            # Finalize prev mode
+            if self.op_mode == OpMode.NONE:
+                self.cbar.btn_poly_type_act_grp.setDisabled(True)
+            elif self.op_mode == OpMode.DRAW_PTS:
+                self.cbar.btn_undo_pt_act.setDisabled(True)
+                self.cbar.btn_redo_pt_act.setDisabled(True)
+                self.cbar.btn_view_lock_center_act.setDisabled(True)
+                # Reset view_lock when exit from DRAW_PTS
+                self.set_view_lock(ViewLock.NONE)
+                # Remove unfinished poly
+                if self.op_poly.get_pts_count() < 3:
+                    self.ie_polys.remove_poly(self.op_poly)
+
+            elif self.op_mode == OpMode.EDIT_PTS:
+                self.cbar.btn_pt_edit_mode_act.setDisabled(True)
+                self.cbar.btn_delete_poly_act.setDisabled(True)
+                # Reset pt_edit_move when exit from EDIT_PTS
+                self.set_pt_edit_mode(PTEditMode.MOVE)
+            elif self.op_mode == OpMode.VIEW_BAKED:
+                self.cbar.btn_view_baked_mask_act.setChecked(False)
+            elif self.op_mode == OpMode.VIEW_XSEG_MASK:
+                self.cbar.btn_view_xseg_mask_act.setChecked(False)
+                self.cbar.btn_xseg_to_poly_act.setDisabled(True)
+            elif self.op_mode == OpMode.VIEW_XSEG_OVERLAY_MASK:
+                self.cbar.btn_view_xseg_overlay_mask_act.setChecked(False)
+                self.cbar.btn_xseg_to_poly_act.setDisabled(True)
+            self.op_mode = op_mode
+
+            # Initialize new mode
+            if op_mode == OpMode.NONE:
+                self.cbar.btn_poly_type_act_grp.setDisabled(False)
+            elif op_mode == OpMode.DRAW_PTS:
+                self.cbar.btn_undo_pt_act.setDisabled(False)
+                self.cbar.btn_redo_pt_act.setDisabled(False)
+                self.cbar.btn_view_lock_center_act.setDisabled(False)
+            elif op_mode == OpMode.EDIT_PTS:
+                self.cbar.btn_pt_edit_mode_act.setDisabled(False)
+                self.cbar.btn_delete_poly_act.setDisabled(False)
+            elif op_mode == OpMode.VIEW_BAKED:
+                self.cbar.btn_view_baked_mask_act.setChecked(True )
+                n = QImage_to_np ( self.q_img ).astype(np.float32) / 255.0
+                h,w,c = n.shape
+                mask = np.zeros( (h,w,1), dtype=np.float32 )
+                self.ie_polys.overlay_mask(mask)
+                n = (mask*255).astype(np.uint8)
+                self.img_baked_pixmap = QPixmap.fromImage(QImage_from_np(n))
+            elif op_mode == OpMode.VIEW_XSEG_MASK:
+                self.cbar.btn_view_xseg_mask_act.setChecked(True)                
+                if self.xseg_mask_in is not None:
+                    self.cbar.btn_xseg_to_poly_act.setDisabled(False)
+            elif op_mode == OpMode.VIEW_XSEG_OVERLAY_MASK:
+                self.cbar.btn_view_xseg_overlay_mask_act.setChecked(True)
+                if self.xseg_mask_in is not None:
+                    self.cbar.btn_xseg_to_poly_act.setDisabled(False)
+                    
+            if op_mode in [OpMode.DRAW_PTS, OpMode.EDIT_PTS]:
+                self.mouse_op_poly_pt_id = None
+                self.mouse_op_poly_edge_id = None
+                self.mouse_op_poly_edge_id_pt = None
+
+            self.op_poly = op_poly
+            if op_poly is not None:
+                self.update_mouse_info()
+
+            self.update_cursor()
+            self.update()
+
+    def set_pt_edit_mode(self, pt_edit_mode):
+        if not hasattr(self, 'pt_edit_mode') or self.pt_edit_mode != pt_edit_mode:
+            self.pt_edit_mode = pt_edit_mode
+            self.update_cursor()
+            self.update()
+        self.cbar.btn_pt_edit_mode_act.setChecked( self.pt_edit_mode == PTEditMode.ADD_DEL )
+
+    def set_view_lock(self, view_lock):
+        if not hasattr(self, 'view_lock') or self.view_lock != view_lock:
+            if hasattr(self, 'view_lock') and self.view_lock != view_lock:
+                if view_lock == ViewLock.CENTER:
+                    self.img_look_pt = self.mouse_img_pt
+                    QCursor.setPos ( self.mapToGlobal( QPoint_from_np(self.img_to_cli_pt(self.img_look_pt)) ))
+
+            self.view_lock = view_lock
+            self.update()
+        self.cbar.btn_view_lock_center_act.setChecked( self.view_lock == ViewLock.CENTER )
+
+    def set_cbar_disabled(self):
+        self.cbar.btn_delete_poly_act.setDisabled(True)
+        self.cbar.btn_undo_pt_act.setDisabled(True)
+        self.cbar.btn_redo_pt_act.setDisabled(True)
+        self.cbar.btn_pt_edit_mode_act.setDisabled(True)
+        self.cbar.btn_view_lock_center_act.setDisabled(True)
+        self.cbar.btn_poly_color_act_grp.setDisabled(True)
+        self.cbar.btn_poly_type_act_grp.setDisabled(True)
+        self.cbar.btn_xseg_to_poly_act.setDisabled(True)
+
+    def set_color_scheme_id(self, id):
+        if self.op_mode == OpMode.VIEW_BAKED:
+            self.set_op_mode(OpMode.NONE)
+
+        if not hasattr(self, 'color_scheme_id') or self.color_scheme_id != id:
+            self.color_scheme_id = id
+            self.update_cursor()
+            self.update()
+
+        if self.color_scheme_id == 0:
+            self.cbar.btn_poly_color_red_act.setChecked( True )
+        elif self.color_scheme_id == 1:
+            self.cbar.btn_poly_color_green_act.setChecked( True )
+        elif self.color_scheme_id == 2:
+            self.cbar.btn_poly_color_blue_act.setChecked( True )
+
+    def set_poly_include_type(self, poly_include_type):
+        if not hasattr(self, 'poly_include_type' ) or \
+           ( self.poly_include_type != poly_include_type and \
+             self.op_mode in [OpMode.NONE, OpMode.EDIT_PTS] ):
+            self.poly_include_type = poly_include_type
+            self.update()
+
+        self.cbar.btn_poly_type_include_act.setChecked(self.poly_include_type == SegIEPolyType.INCLUDE)
+        self.cbar.btn_poly_type_exclude_act.setChecked(self.poly_include_type == SegIEPolyType.EXCLUDE)
+
+    def set_view_xseg_mask(self, is_checked):
+        if is_checked:
+            self.set_op_mode(OpMode.VIEW_XSEG_MASK)
+        else:
+            self.set_op_mode(OpMode.NONE)
+
+        self.cbar.btn_view_xseg_mask_act.setChecked(is_checked )
+
+    def set_view_xseg_overlay_mask(self, is_checked):
+        if is_checked:
+            self.set_op_mode(OpMode.VIEW_XSEG_OVERLAY_MASK)
+        else:
+            self.set_op_mode(OpMode.NONE)
+
+        self.cbar.btn_view_xseg_overlay_mask_act.setChecked(is_checked )
+
+    # ====================================================================================
+    # ====================================================================================
+    # ====================================== METHODS =====================================
+    # ====================================================================================
+    # ====================================================================================
+
+    def update_cursor(self, is_finalize=False):
+        if not self.initialized:
+            return
+
+        if not self.mouse_in_widget or is_finalize:
+            if self.current_cursor is not None:
+                QApplication.restoreOverrideCursor()
+                self.current_cursor = None
+        else:
+            color_cc = self.get_current_color_scheme().cross_cursor
+            nc = Qt.ArrowCursor
+
+            if self.drag_type == DragType.IMAGE_LOOK:
+                nc = Qt.ClosedHandCursor
+            else:
+
+                if self.op_mode == OpMode.NONE:
+                    nc = color_cc
+                    if self.mouse_wire_poly is not None:
+                        nc = Qt.PointingHandCursor
+
+                elif self.op_mode == OpMode.DRAW_PTS:
+                    nc = color_cc
+                elif self.op_mode == OpMode.EDIT_PTS:
+                    nc = Qt.ArrowCursor
+
+                    if self.mouse_op_poly_pt_id is not None:
+                        nc = Qt.PointingHandCursor
+
+                    if self.pt_edit_mode == PTEditMode.ADD_DEL:
+
+                        if self.mouse_op_poly_edge_id is not None and \
+                        self.mouse_op_poly_pt_id is None:
+                            nc = color_cc
+            if self.current_cursor != nc:
+                if self.current_cursor is None:
+                    QApplication.setOverrideCursor(nc)
+                else:
+                    QApplication.changeOverrideCursor(nc)
+                self.current_cursor = nc
+
+    def update_mouse_info(self, mouse_cli_pt=None):
+        """
+        Update selected polys/edges/points by given mouse position
+        """
+        if mouse_cli_pt is not None:
+            self.mouse_cli_pt = mouse_cli_pt.astype(np.float32)
+
+        self.mouse_img_pt = self.cli_to_img_pt(self.mouse_cli_pt)
+
+        new_mouse_hull_poly = self.get_poly_by_pt_in_hull(self.mouse_cli_pt)
+
+        if self.mouse_hull_poly != new_mouse_hull_poly:
+            self.mouse_hull_poly = new_mouse_hull_poly
+            self.update_cursor()
+            self.update()
+
+        new_mouse_wire_poly = self.get_poly_by_pt_near_wire(self.mouse_cli_pt)
+
+        if self.mouse_wire_poly != new_mouse_wire_poly:
+            self.mouse_wire_poly = new_mouse_wire_poly
+            self.update_cursor()
+            self.update()
+
+        if self.op_mode in [OpMode.DRAW_PTS, OpMode.EDIT_PTS]:
+            new_mouse_op_poly_pt_id = self.get_poly_pt_id_under_pt (self.op_poly, self.mouse_cli_pt)
+            if self.mouse_op_poly_pt_id != new_mouse_op_poly_pt_id:
+                self.mouse_op_poly_pt_id = new_mouse_op_poly_pt_id
+                self.update_cursor()
+                self.update()
+
+            new_mouse_op_poly_edge_id,\
+            new_mouse_op_poly_edge_id_pt = self.get_poly_edge_id_pt_under_pt (self.op_poly, self.mouse_cli_pt)
+            if self.mouse_op_poly_edge_id != new_mouse_op_poly_edge_id:
+                self.mouse_op_poly_edge_id = new_mouse_op_poly_edge_id
+                self.update_cursor()
+                self.update()
+
+            if (self.mouse_op_poly_edge_id_pt.__class__ != new_mouse_op_poly_edge_id_pt.__class__) or \
+               (isinstance(self.mouse_op_poly_edge_id_pt, np.ndarray) and \
+                all(self.mouse_op_poly_edge_id_pt != new_mouse_op_poly_edge_id_pt)):
+
+                self.mouse_op_poly_edge_id_pt = new_mouse_op_poly_edge_id_pt
+                self.update_cursor()
+                self.update()
+
+
+    def action_undo_pt(self):
+        if self.drag_type == DragType.NONE:
+            if self.op_mode == OpMode.DRAW_PTS:
+                if self.op_poly.undo() == 0:
+                    self.ie_polys.remove_poly (self.op_poly)
+                    self.set_op_mode(OpMode.NONE)
+                self.update()
+
+    def action_redo_pt(self):
+        if self.drag_type == DragType.NONE:
+            if self.op_mode == OpMode.DRAW_PTS:
+                self.op_poly.redo()
+                self.update()
+
+    def action_delete_poly(self):
+        if self.op_mode == OpMode.EDIT_PTS and \
+            self.drag_type == DragType.NONE and \
+            self.pt_edit_mode == PTEditMode.MOVE:
+            # Delete current poly
+            self.ie_polys.remove_poly (self.op_poly)
+            self.set_op_mode(OpMode.NONE)
+
+    def action_xseg_to_poly(self):
+        
+        cnts = cv2.findContours( (self.xseg_mask_in*255).astype(np.uint8), cv2.RETR_LIST, cv2.CHAIN_APPROX_TC89_KCOS)        
+        # Sort by countour area      
+        cnts = sorted(cnts[0], key = cv2.contourArea, reverse = True)
+        if len(cnts) != 0:            
+            h,w,c = self.img.shape
+            mh,mw,mc = self.xseg_mask_in.shape
+            
+            dh = h / mh
+            dw = w / mw
+            
+            new_poly = self.ie_polys.add_poly(SegIEPolyType.INCLUDE)
+            for pt in cnts[0].squeeze():            
+                new_poly.add_pt( pt[0]*dw, pt[1]*dh )
+            
+            self.set_op_mode(OpMode.EDIT_PTS, op_poly=new_poly)
+            
+        
+    # ====================================================================================
+    # ====================================================================================
+    # ================================== OVERRIDE QT METHODS =============================
+    # ====================================================================================
+    # ====================================================================================
+    def on_keyPressEvent(self, ev):
+        if not self.initialized:
+            return
+        key = ev.key()
+        key_mods = int(ev.modifiers())
+        if self.op_mode == OpMode.DRAW_PTS:
+            self.set_view_lock(ViewLock.CENTER if key_mods == Qt.ShiftModifier else ViewLock.NONE )
+        elif self.op_mode == OpMode.EDIT_PTS:
+            self.set_pt_edit_mode(PTEditMode.ADD_DEL if key_mods == Qt.ControlModifier else PTEditMode.MOVE )
+
+    def on_keyReleaseEvent(self, ev):
+        if not self.initialized:
+            return
+        key = ev.key()
+        key_mods = int(ev.modifiers())
+        if self.op_mode == OpMode.DRAW_PTS:
+            self.set_view_lock(ViewLock.CENTER if key_mods == Qt.ShiftModifier else ViewLock.NONE )
+        elif self.op_mode == OpMode.EDIT_PTS:
+            self.set_pt_edit_mode(PTEditMode.ADD_DEL if key_mods == Qt.ControlModifier else PTEditMode.MOVE )
+
+    def enterEvent(self, ev):
+        super().enterEvent(ev)
+        self.mouse_in_widget = True
+        self.update_cursor()
+
+    def leaveEvent(self, ev):
+        super().leaveEvent(ev)
+        self.mouse_in_widget = False
+        self.update_cursor()
+
+    def mousePressEvent(self, ev):
+        super().mousePressEvent(ev)
+        if not self.initialized:
+            return
+
+        self.update_mouse_info(QPoint_to_np(ev.pos()))
+
+        btn = ev.button()
+
+        if btn == Qt.LeftButton:
+            if self.op_mode == OpMode.NONE:
+                # Clicking in NO OPERATION mode
+                if self.mouse_wire_poly is not None:
+                    # Click on wire on any poly -> switch to EDIT_MODE
+                    self.set_op_mode(OpMode.EDIT_PTS, op_poly=self.mouse_wire_poly)
+                else:
+                    # Click on empty space -> create new poly with one point
+                    new_poly = self.ie_polys.add_poly(self.poly_include_type)
+                    self.ie_polys.sort()
+                    new_poly.add_pt(*self.mouse_img_pt)
+                    self.set_op_mode(OpMode.DRAW_PTS, op_poly=new_poly )
+
+            elif self.op_mode == OpMode.DRAW_PTS:
+                # Clicking in DRAW_PTS mode
+                if len(self.op_poly.get_pts()) >= 3 and self.mouse_op_poly_pt_id == 0:
+                    # Click on first point -> close poly and switch to edit mode
+                    self.set_op_mode(OpMode.EDIT_PTS, op_poly=self.op_poly)
+                else:
+                    # Click on empty space -> add point to current poly
+                    self.op_poly.add_pt(*self.mouse_img_pt)
+                    self.update()
+
+            elif self.op_mode == OpMode.EDIT_PTS:
+                # Clicking in EDIT_PTS mode
+
+                if self.mouse_op_poly_pt_id is not None:
+                    # Click on point of op_poly
+                    if self.pt_edit_mode == PTEditMode.ADD_DEL:
+                        # with mode -> delete point
+                        self.op_poly.remove_pt(self.mouse_op_poly_pt_id)
+                        if self.op_poly.get_pts_count() < 3:
+                            # not enough points -> remove poly
+                            self.ie_polys.remove_poly (self.op_poly)
+                            self.set_op_mode(OpMode.NONE)
+                        self.update()
+
+                    elif self.drag_type == DragType.NONE:
+                        # otherwise -> start drag
+                        self.drag_type = DragType.POLY_PT
+                        self.drag_cli_pt     = self.mouse_cli_pt
+                        self.drag_poly_pt_id = self.mouse_op_poly_pt_id
+                        self.drag_poly_pt    = self.op_poly.get_pts()[ self.drag_poly_pt_id ]
+                elif self.mouse_op_poly_edge_id is not None:
+                    # Click on edge of op_poly
+                    if self.pt_edit_mode == PTEditMode.ADD_DEL:
+                        # with mode -> insert new point
+                        edge_img_pt = self.cli_to_img_pt(self.mouse_op_poly_edge_id_pt)
+                        self.op_poly.insert_pt (self.mouse_op_poly_edge_id+1, edge_img_pt)
+                        self.update()
+                    else:
+                        # Otherwise do nothing
+                        pass
+                else:
+                    # other cases -> unselect poly
+                    self.set_op_mode(OpMode.NONE)
+
+        elif btn == Qt.MiddleButton:
+            if self.drag_type == DragType.NONE:
+                # Start image drag
+                self.drag_type = DragType.IMAGE_LOOK
+                self.drag_cli_pt = self.mouse_cli_pt
+                self.drag_img_look_pt = self.get_img_look_pt()
+                self.update_cursor()
+
+
+    def mouseReleaseEvent(self, ev):
+        super().mouseReleaseEvent(ev)
+        if not self.initialized:
+            return
+
+        self.update_mouse_info(QPoint_to_np(ev.pos()))
+
+        btn = ev.button()
+
+        if btn == Qt.LeftButton:
+            if self.op_mode == OpMode.EDIT_PTS:
+                if self.drag_type == DragType.POLY_PT:
+                    self.drag_type = DragType.NONE
+                    self.update()
+
+        elif btn == Qt.MiddleButton:
+            if self.drag_type == DragType.IMAGE_LOOK:
+                self.drag_type = DragType.NONE
+                self.update_cursor()
+                self.update()
+
+    def mouseMoveEvent(self, ev):
+        super().mouseMoveEvent(ev)
+        if not self.initialized:
+            return
+
+        prev_mouse_cli_pt = self.mouse_cli_pt
+        self.update_mouse_info(QPoint_to_np(ev.pos()))
+
+        if self.view_lock == ViewLock.CENTER:
+            if npla.norm(self.mouse_cli_pt - prev_mouse_cli_pt) >= 1:
+                self.img_look_pt = self.mouse_img_pt
+                QCursor.setPos ( self.mapToGlobal( QPoint_from_np(self.img_to_cli_pt(self.img_look_pt)) ))
+
+            self.update()
+
+        if self.drag_type == DragType.IMAGE_LOOK:
+            delta_pt = self.cli_to_img_pt(self.mouse_cli_pt) - self.cli_to_img_pt(self.drag_cli_pt)
+            self.img_look_pt = self.drag_img_look_pt - delta_pt
+            self.update()
+
+        if self.op_mode == OpMode.DRAW_PTS:
+            self.update()
+        elif self.op_mode == OpMode.EDIT_PTS:
+            if self.drag_type == DragType.POLY_PT:
+                delta_pt = self.cli_to_img_pt(self.mouse_cli_pt) - self.cli_to_img_pt(self.drag_cli_pt)
+                self.op_poly.set_point(self.drag_poly_pt_id, self.drag_poly_pt + delta_pt)
+                self.update()
+
+    def wheelEvent(self, ev):
+        super().wheelEvent(ev)
+
+        if not self.initialized:
+            return
+
+        mods = int(ev.modifiers())
+        delta = ev.angleDelta()
+
+        cli_pt = QPoint_to_np(ev.pos())
+
+        if self.drag_type == DragType.NONE:
+            sign = np.sign( delta.y() )
+            prev_img_pos = self.cli_to_img_pt (cli_pt)
+            delta_scale = sign*0.2 + sign * self.get_view_scale() / 10.0
+            self.view_scale = np.clip(self.get_view_scale() + delta_scale, 1.0, 20.0)
+            new_img_pos = self.cli_to_img_pt (cli_pt)
+            if sign > 0:
+                self.img_look_pt = self.get_img_look_pt() + (prev_img_pos-new_img_pos)#*1.5
+            else:
+                QCursor.setPos ( self.mapToGlobal(QPoint_from_np(self.img_to_cli_pt(prev_img_pos))) )
+            self.update()
+
+    def paintEvent(self, event):
+        super().paintEvent(event)
+        if not self.initialized:
+            return
+
+        qp = self.qp
+        qp.begin(self)
+        qp.setRenderHint(QPainter.Antialiasing)
+        qp.setRenderHint(QPainter.HighQualityAntialiasing)
+        qp.setRenderHint(QPainter.SmoothPixmapTransform)
+
+        src_rect = QRect(0, 0, *self.img_size)
+        dst_rect = self.img_to_cli_rect( src_rect )
+
+        if self.op_mode == OpMode.VIEW_BAKED:
+            qp.drawPixmap(dst_rect, self.img_baked_pixmap, src_rect)
+        elif self.op_mode == OpMode.VIEW_XSEG_MASK:
+            if self.xseg_mask_pixmap is not None:
+                qp.drawPixmap(dst_rect, self.xseg_mask_pixmap, src_rect)
+        elif self.op_mode == OpMode.VIEW_XSEG_OVERLAY_MASK:
+            if self.xseg_overlay_mask_pixmap is not None:
+                qp.drawPixmap(dst_rect, self.xseg_overlay_mask_pixmap, src_rect)
+        else:
+            if self.img_pixmap is not None:
+                qp.drawPixmap(dst_rect, self.img_pixmap, src_rect)
+
+            polys = self.ie_polys.get_polys()
+            polys_len = len(polys)
+
+            color_scheme = self.get_current_color_scheme()
+
+            pt_rad = self.canvas_config.pt_radius
+            pt_rad_x2 = pt_rad*2
+
+            pt_select_radius = self.canvas_config.pt_select_radius
+
+            op_mode = self.op_mode
+            op_poly = self.op_poly
+
+            for i,poly in enumerate(polys):
+
+                selected_pt_path = QPainterPath()
+                poly_line_path = QPainterPath()
+                pts_line_path = QPainterPath()
+
+                pt_remove_cli_pt = None
+                poly_pts = poly.get_pts()
+                for pt_id, img_pt in enumerate(poly_pts):
+                    cli_pt = self.img_to_cli_pt(img_pt)
+                    q_cli_pt = QPoint_from_np(cli_pt)
+
+                    if pt_id == 0:
+                        poly_line_path.moveTo(q_cli_pt)
+                    else:
+                        poly_line_path.lineTo(q_cli_pt)
+
+
+                    if poly == op_poly:
+                        if self.op_mode == OpMode.DRAW_PTS or \
+                            (self.op_mode == OpMode.EDIT_PTS and \
+                            (self.pt_edit_mode == PTEditMode.MOVE) or \
+                            (self.pt_edit_mode == PTEditMode.ADD_DEL and self.mouse_op_poly_pt_id == pt_id) \
+                            ):
+                            pts_line_path.moveTo( QPoint_from_np(cli_pt + np.float32([0,-pt_rad])) )
+                            pts_line_path.lineTo( QPoint_from_np(cli_pt + np.float32([0,pt_rad])) )
+                            pts_line_path.moveTo( QPoint_from_np(cli_pt + np.float32([-pt_rad,0])) )
+                            pts_line_path.lineTo( QPoint_from_np(cli_pt + np.float32([pt_rad,0])) )
+
+                        if (self.op_mode == OpMode.EDIT_PTS and \
+                            self.pt_edit_mode == PTEditMode.ADD_DEL and \
+                            self.mouse_op_poly_pt_id == pt_id):
+                            pt_remove_cli_pt = cli_pt
+
+                        if self.op_mode == OpMode.DRAW_PTS and \
+                            len(op_poly.get_pts()) >= 3 and pt_id == 0 and self.mouse_op_poly_pt_id == pt_id:
+                            # Circle around poly point
+                            selected_pt_path.addEllipse(q_cli_pt, pt_rad_x2, pt_rad_x2)
+
+
+                if poly == op_poly:
+                    if op_mode == OpMode.DRAW_PTS:
+                        # Line from last point to mouse
+                        poly_line_path.lineTo( QPoint_from_np(self.mouse_cli_pt) )
+
+                    if self.mouse_op_poly_pt_id is not None:
+                        pass
+
+                    if self.mouse_op_poly_edge_id_pt is not None:
+                        if self.pt_edit_mode == PTEditMode.ADD_DEL and self.mouse_op_poly_pt_id is None:
+                            # Ready to insert point on edge
+                            m_cli_pt = self.mouse_op_poly_edge_id_pt
+                            pts_line_path.moveTo( QPoint_from_np(m_cli_pt + np.float32([0,-pt_rad])) )
+                            pts_line_path.lineTo( QPoint_from_np(m_cli_pt + np.float32([0,pt_rad])) )
+                            pts_line_path.moveTo( QPoint_from_np(m_cli_pt + np.float32([-pt_rad,0])) )
+                            pts_line_path.lineTo( QPoint_from_np(m_cli_pt + np.float32([pt_rad,0])) )
+
+                if len(poly_pts) >= 2:
+                    # Closing poly line
+                    poly_line_path.lineTo( QPoint_from_np(self.img_to_cli_pt(poly_pts[0])) )
+
+                # Draw calls
+                qp.setPen(color_scheme.pt_outline_pen)
+                qp.setBrush(QBrush())
+                qp.drawPath(selected_pt_path)
+
+                qp.setPen(color_scheme.poly_outline_solid_pen)
+                qp.setBrush(QBrush())
+                qp.drawPath(pts_line_path)
+
+                if poly.get_type() == SegIEPolyType.INCLUDE:
+                    qp.setPen(color_scheme.poly_outline_solid_pen)
+                else:
+                    qp.setPen(color_scheme.poly_outline_dot_pen)
+
+                qp.setBrush(color_scheme.poly_unselected_brush)
+                if op_mode == OpMode.NONE:
+                    if poly == self.mouse_wire_poly:
+                        qp.setBrush(color_scheme.poly_selected_brush)
+                #else:
+                #    if poly == op_poly:
+                #        qp.setBrush(color_scheme.poly_selected_brush)
+
+                qp.drawPath(poly_line_path)
+
+                if pt_remove_cli_pt is not None:
+                    qp.setPen(color_scheme.poly_outline_solid_pen)
+                    qp.setBrush(QBrush())
+
+                    qp.drawLine( *(pt_remove_cli_pt + np.float32([-pt_rad_x2,-pt_rad_x2])), *(pt_remove_cli_pt + np.float32([pt_rad_x2,pt_rad_x2])) )
+                    qp.drawLine( *(pt_remove_cli_pt + np.float32([-pt_rad_x2,pt_rad_x2])), *(pt_remove_cli_pt + np.float32([pt_rad_x2,-pt_rad_x2])) )
+
+        qp.end()
+
+class QCanvas(QFrame):
+    def __init__(self):
+        super().__init__()
+
+        self.canvas_control_left_bar = QCanvasControlsLeftBar()
+        self.canvas_control_right_bar = QCanvasControlsRightBar()
+
+        cbar = sn( btn_poly_color_red_act   = self.canvas_control_right_bar.btn_poly_color_red_act,
+                   btn_poly_color_green_act = self.canvas_control_right_bar.btn_poly_color_green_act,
+                   btn_poly_color_blue_act  = self.canvas_control_right_bar.btn_poly_color_blue_act,
+                   btn_view_baked_mask_act  = self.canvas_control_right_bar.btn_view_baked_mask_act,
+                   btn_view_xseg_mask_act  = self.canvas_control_right_bar.btn_view_xseg_mask_act,
+                   btn_view_xseg_overlay_mask_act  = self.canvas_control_right_bar.btn_view_xseg_overlay_mask_act,
+                   btn_poly_color_act_grp = self.canvas_control_right_bar.btn_poly_color_act_grp,
+                   btn_xseg_to_poly_act = self.canvas_control_right_bar.btn_xseg_to_poly_act,
+
+                   btn_poly_type_include_act = self.canvas_control_left_bar.btn_poly_type_include_act,
+                   btn_poly_type_exclude_act = self.canvas_control_left_bar.btn_poly_type_exclude_act,
+                   btn_poly_type_act_grp = self.canvas_control_left_bar.btn_poly_type_act_grp,
+                   btn_undo_pt_act = self.canvas_control_left_bar.btn_undo_pt_act,
+                   btn_redo_pt_act = self.canvas_control_left_bar.btn_redo_pt_act,
+                   btn_delete_poly_act = self.canvas_control_left_bar.btn_delete_poly_act,
+                   btn_pt_edit_mode_act = self.canvas_control_left_bar.btn_pt_edit_mode_act,                   
+                   btn_view_lock_center_act = self.canvas_control_left_bar.btn_view_lock_center_act, )
+
+        self.op = QCanvasOperator(cbar)
+        self.l = QHBoxLayout()
+        self.l.setContentsMargins(0,0,0,0)
+        self.l.addWidget(self.canvas_control_left_bar)
+        self.l.addWidget(self.op)
+        self.l.addWidget(self.canvas_control_right_bar)
+        self.setLayout(self.l)
+
+class LoaderQSubprocessor(QSubprocessor):
+    def __init__(self, image_paths, q_label, q_progressbar, on_finish_func ):
+
+        self.image_paths = image_paths
+        self.image_paths_len = len(image_paths)
+        self.idxs = [*range(self.image_paths_len)]
+
+        self.filtered_image_paths = self.image_paths.copy()
+
+        self.image_paths_has_ie_polys = { image_path : False for image_path in self.image_paths }
+
+        self.q_label = q_label
+        self.q_progressbar = q_progressbar
+        self.q_progressbar.setRange(0, self.image_paths_len)
+        self.q_progressbar.setValue(0)
+        self.q_progressbar.update()
+        self.on_finish_func = on_finish_func
+        self.done_count = 0
+        super().__init__('LoaderQSubprocessor', LoaderQSubprocessor.Cli, 60)
+
+    def get_data(self, host_dict):
+        if len (self.idxs) > 0:
+            idx = self.idxs.pop(0)
+            image_path = self.image_paths[idx]
+            self.q_label.setText(f'{QStringDB.loading_tip}... {image_path.name}')
+
+            return idx, image_path
+
+        return None
+
+    def on_clients_finalized(self):
+        self.on_finish_func([x for x in self.filtered_image_paths if x is not None], self.image_paths_has_ie_polys)
+
+    def on_data_return (self, host_dict, data):
+        self.idxs.insert(0, data[0])
+
+    def on_result (self, host_dict, data, result):
+        idx, has_dflimg, has_ie_polys = result
+
+        if not has_dflimg:
+            self.filtered_image_paths[idx] = None
+        self.image_paths_has_ie_polys[self.image_paths[idx]] = has_ie_polys
+
+        self.done_count += 1
+        if self.q_progressbar is not None:
+            self.q_progressbar.setValue(self.done_count)
+
+    class Cli(QSubprocessor.Cli):
+        def process_data(self, data):
+            idx, filename = data
+            dflimg = DFLIMG.load(filename)
+            if dflimg is not None and dflimg.has_data():
+                ie_polys = dflimg.get_seg_ie_polys()
+
+                return idx, True, ie_polys.has_polys()
+            return idx, False, False
+
+class MainWindow(QXMainWindow):
+
+    def __init__(self, input_dirpath, cfg_root_path):
+        self.loading_frame = None
+        self.help_frame = None
+
+        super().__init__()
+
+        self.input_dirpath = input_dirpath
+        self.cfg_root_path = cfg_root_path
+
+        self.cfg_path = cfg_root_path / 'MainWindow_cfg.dat'
+        self.cfg_dict = pickle.loads(self.cfg_path.read_bytes()) if self.cfg_path.exists() else {}
+
+        self.cached_images = {}
+        self.cached_has_ie_polys = {}
+
+        self.initialize_ui()
+
+        # Loader
+        self.loading_frame = QFrame(self.main_canvas_frame)
+        self.loading_frame.setAutoFillBackground(True)
+        self.loading_frame.setFrameShape(QFrame.StyledPanel)
+        self.loader_label = QLabel()
+        self.loader_progress_bar = QProgressBar()
+
+        intro_image = QLabel()
+        intro_image.setPixmap( QPixmap.fromImage(QImageDB.intro) )
+
+        intro_image_frame_l = QVBoxLayout()
+        intro_image_frame_l.addWidget(intro_image, alignment=Qt.AlignCenter)
+        intro_image_frame = QFrame()
+        intro_image_frame.setSizePolicy (QSizePolicy.Expanding, QSizePolicy.Expanding)
+        intro_image_frame.setLayout(intro_image_frame_l)
+
+        loading_frame_l = QVBoxLayout()
+        loading_frame_l.addWidget (intro_image_frame)
+        loading_frame_l.addWidget (self.loader_label)
+        loading_frame_l.addWidget (self.loader_progress_bar)
+        self.loading_frame.setLayout(loading_frame_l)
+
+        self.loader_subprocessor = LoaderQSubprocessor( image_paths=pathex.get_image_paths(input_dirpath, return_Path_class=True),
+                                                        q_label=self.loader_label,
+                                                        q_progressbar=self.loader_progress_bar,
+                                                        on_finish_func=self.on_loader_finish )
+
+
+    def on_loader_finish(self, image_paths, image_paths_has_ie_polys):
+        self.image_paths_done = []
+        self.image_paths = image_paths
+        self.image_paths_has_ie_polys = image_paths_has_ie_polys
+        self.set_has_ie_polys_count ( len([ 1 for x in self.image_paths_has_ie_polys if self.image_paths_has_ie_polys[x] == True]) )
+        self.loading_frame.hide()
+        self.loading_frame = None
+
+        self.process_next_image(first_initialization=True)
+
+    def closeEvent(self, ev):
+        self.cfg_dict['geometry'] = self.saveGeometry().data()
+        self.cfg_path.write_bytes( pickle.dumps(self.cfg_dict) )
+
+
+    def update_cached_images (self, count=5):
+        d = self.cached_images
+
+        for image_path in self.image_paths_done[:-count]+self.image_paths[count:]:
+            if image_path in d:
+                del d[image_path]
+
+        for image_path in self.image_paths[:count]+self.image_paths_done[-count:]:
+            if image_path not in d:
+                img = cv2_imread(image_path)
+                if img is not None:
+                    d[image_path] = img
+
+    def load_image(self, image_path):
+        try:
+            img = self.cached_images.get(image_path, None)
+            if img is None:
+                img = cv2_imread(image_path)
+                self.cached_images[image_path] = img
+            if img is None:
+                io.log_err(f'Unable to load {image_path}')
+        except:
+            img = None
+
+        return img
+
+    def update_preview_bar(self):
+        count = self.image_bar.get_preview_images_count()
+        d = self.cached_images
+        prev_imgs = [ d.get(image_path, None) for image_path in self.image_paths_done[-1:-count:-1] ]
+        next_imgs = [ d.get(image_path, None) for image_path in self.image_paths[:count] ]
+        self.image_bar.update_images(prev_imgs, next_imgs)
+
+
+    def canvas_initialize(self, image_path, only_has_polys=False):
+        if only_has_polys and not self.image_paths_has_ie_polys[image_path]:
+            return False
+
+        dflimg = DFLIMG.load(image_path)
+        if not dflimg or not dflimg.has_data():
+            return False
+
+        ie_polys = dflimg.get_seg_ie_polys()
+        xseg_mask = dflimg.get_xseg_mask()
+        img = self.load_image(image_path)
+        if img is None:
+            return False
+
+        self.canvas.op.initialize ( img,  ie_polys=ie_polys, xseg_mask=xseg_mask )
+
+        self.filename_label.setText(f"{image_path.name}")
+
+        return True
+
+    def canvas_finalize(self, image_path):
+        self.canvas.op.finalize()
+
+        if image_path.exists():
+            dflimg = DFLIMG.load(image_path)
+            ie_polys = dflimg.get_seg_ie_polys()
+            new_ie_polys = self.canvas.op.get_ie_polys()
+
+            if not new_ie_polys.identical(ie_polys):
+                new_has_ie_polys = new_ie_polys.has_polys()
+                self.set_has_ie_polys_count ( self.get_has_ie_polys_count() + (1 if new_has_ie_polys else -1) )
+                self.image_paths_has_ie_polys[image_path] = new_has_ie_polys
+                dflimg.set_seg_ie_polys( new_ie_polys )
+                dflimg.save()
+
+        self.filename_label.setText(f"")
+
+    def process_prev_image(self):
+        key_mods = QApplication.keyboardModifiers()
+        step = 5 if key_mods == Qt.ShiftModifier else 1
+        only_has_polys = key_mods == Qt.ControlModifier
+
+        if self.canvas.op.is_initialized():
+            self.canvas_finalize(self.image_paths[0])
+
+        while True:
+            for _ in range(step):
+                if len(self.image_paths_done) != 0:
+                    self.image_paths.insert (0, self.image_paths_done.pop(-1))
+                else:
+                    break
+            if len(self.image_paths) == 0:
+                break
+
+            ret = self.canvas_initialize(self.image_paths[0], len(self.image_paths_done) != 0 and only_has_polys)
+
+            if ret or len(self.image_paths_done) == 0:
+                break
+
+        self.update_cached_images()
+        self.update_preview_bar()
+
+    def process_next_image(self, first_initialization=False):
+        key_mods = QApplication.keyboardModifiers()
+
+        step = 0 if first_initialization else 5 if key_mods == Qt.ShiftModifier else 1
+        only_has_polys = False if first_initialization else key_mods == Qt.ControlModifier
+
+        if self.canvas.op.is_initialized():
+            self.canvas_finalize(self.image_paths[0])
+
+        while True:
+            for _ in range(step):
+                if len(self.image_paths) != 0:
+                    self.image_paths_done.append(self.image_paths.pop(0))
+                else:
+                    break
+            if len(self.image_paths) == 0:
+                break
+            if self.canvas_initialize(self.image_paths[0], only_has_polys):
+                break
+
+        self.update_cached_images()
+        self.update_preview_bar()
+
+    def initialize_ui(self):
+
+        self.canvas = QCanvas()
+
+        image_bar = self.image_bar = ImagePreviewSequenceBar(preview_images_count=9, icon_size=QUIConfig.preview_bar_icon_q_size.width())
+        image_bar.setSizePolicy ( QSizePolicy.Fixed, QSizePolicy.Fixed )
+
+
+        btn_prev_image = QXIconButton(QIconDB.left, QStringDB.btn_prev_image_tip, shortcut='A', click_func=self.process_prev_image)
+        btn_prev_image.setIconSize(QUIConfig.preview_bar_icon_q_size)
+
+        btn_next_image = QXIconButton(QIconDB.right, QStringDB.btn_next_image_tip, shortcut='D', click_func=self.process_next_image)
+        btn_next_image.setIconSize(QUIConfig.preview_bar_icon_q_size)
+
+
+        preview_image_bar_frame_l = QHBoxLayout()
+        preview_image_bar_frame_l.setContentsMargins(0,0,0,0)
+        preview_image_bar_frame_l.addWidget ( btn_prev_image, alignment=Qt.AlignCenter)
+        preview_image_bar_frame_l.addWidget ( image_bar)
+        preview_image_bar_frame_l.addWidget ( btn_next_image, alignment=Qt.AlignCenter)
+
+        preview_image_bar_frame = QFrame()
+        preview_image_bar_frame.setSizePolicy ( QSizePolicy.Fixed, QSizePolicy.Fixed )
+        preview_image_bar_frame.setLayout(preview_image_bar_frame_l)
+
+        preview_image_bar_l = QHBoxLayout()
+        preview_image_bar_l.addWidget (preview_image_bar_frame)
+
+        preview_image_bar = QFrame()
+        preview_image_bar.setFrameShape(QFrame.StyledPanel)
+        preview_image_bar.setSizePolicy ( QSizePolicy.Expanding, QSizePolicy.Fixed )
+        preview_image_bar.setLayout(preview_image_bar_l)
+
+        label_font = QFont('Courier New')
+        self.filename_label = QLabel()
+        self.filename_label.setFont(label_font)
+
+        self.has_ie_polys_count_label = QLabel()
+
+        status_frame_l = QHBoxLayout()
+        status_frame_l.setContentsMargins(0,0,0,0)
+        status_frame_l.addWidget ( QLabel(), alignment=Qt.AlignCenter)
+        status_frame_l.addWidget (self.filename_label, alignment=Qt.AlignCenter)
+        status_frame_l.addWidget (self.has_ie_polys_count_label, alignment=Qt.AlignCenter)
+        status_frame = QFrame()
+        status_frame.setLayout(status_frame_l)
+
+        main_canvas_l = QVBoxLayout()
+        main_canvas_l.setContentsMargins(0,0,0,0)
+        main_canvas_l.addWidget (self.canvas)
+        main_canvas_l.addWidget (status_frame)
+        main_canvas_l.addWidget (preview_image_bar)
+
+        self.main_canvas_frame = QFrame()
+        self.main_canvas_frame.setLayout(main_canvas_l)
+
+        self.main_l = QHBoxLayout()
+        self.main_l.setContentsMargins(0,0,0,0)
+        self.main_l.addWidget (self.main_canvas_frame)
+
+        self.setLayout(self.main_l)
+
+        geometry = self.cfg_dict.get('geometry', None)
+        if geometry is not None:
+            self.restoreGeometry(geometry)
+        else:
+            self.move( QPoint(0,0))
+
+    def get_has_ie_polys_count(self):
+        return self.has_ie_polys_count
+
+    def set_has_ie_polys_count(self, c):
+        self.has_ie_polys_count = c
+        self.has_ie_polys_count_label.setText(f"{c} {QStringDB.labeled_tip}")
+
+    def resizeEvent(self, ev):
+        if self.loading_frame is not None:
+            self.loading_frame.resize( ev.size() )
+        if self.help_frame is not None:
+            self.help_frame.resize( ev.size() )
+
+def start(input_dirpath):
+    """
+    returns exit_code
+    """
+    io.log_info("Running XSeg editor.")
+
+    if PackedFaceset.path_contains(input_dirpath):
+        io.log_info (f'\n{input_dirpath} contains packed faceset! Unpack it first.\n')
+        return 1
+
+    root_path = Path(__file__).parent
+    cfg_root_path = Path(tempfile.gettempdir())
+
+    QApplication.setAttribute(Qt.AA_EnableHighDpiScaling, True)
+    QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps, True)
+
+    app = QApplication([])
+    app.setApplicationName("XSegEditor")
+    app.setStyle('Fusion')
+
+    QFontDatabase.addApplicationFont( str(root_path / 'gfx' / 'fonts' / 'NotoSans-Medium.ttf') )
+
+    app.setFont( QFont('NotoSans'))
+
+    QUIConfig.initialize()
+    QStringDB.initialize()
+
+    QIconDB.initialize( root_path / 'gfx' / 'icons' )
+    QCursorDB.initialize( root_path / 'gfx' / 'cursors' )
+    QImageDB.initialize( root_path / 'gfx' / 'images' )
+
+    app.setWindowIcon(QIconDB.app_icon)
+    app.setPalette( QDarkPalette() )
+
+    win = MainWindow( input_dirpath=input_dirpath, cfg_root_path=cfg_root_path)
+
+    win.show()
+    win.raise_()
+
+    app.exec_()
+    return 0

XSegEditor/XSegEditor.py

@@ -0,0 +1,1494 @@
+import json
+import multiprocessing
+import os
+import pickle
+import sys
+import tempfile
+import time
+import traceback
+from enum import IntEnum
+from types import SimpleNamespace as sn
+
+import cv2
+import numpy as np
+import numpy.linalg as npla
+from PyQt5.QtCore import *
+from PyQt5.QtGui import *
+from PyQt5.QtWidgets import *
+
+from core import imagelib, pathex
+from core.cv2ex import *
+from core.imagelib import SegIEPoly, SegIEPolys, SegIEPolyType, sd
+from core.qtex import *
+from DFLIMG import *
+from localization import StringsDB, system_language
+from samplelib import PackedFaceset
+
+from .QCursorDB import QCursorDB
+from .QIconDB import QIconDB
+from .QStringDB import QStringDB
+from .QImageDB import QImageDB
+
+class OpMode(IntEnum):
+    NONE = 0
+    DRAW_PTS = 1
+    EDIT_PTS = 2
+    VIEW_BAKED = 3
+    VIEW_XSEG_MASK = 4
+
+class PTEditMode(IntEnum):
+    MOVE = 0
+    ADD_DEL = 1
+
+class DragType(IntEnum):
+    NONE = 0
+    IMAGE_LOOK = 1
+    POLY_PT = 2
+
+class ViewLock(IntEnum):
+    NONE = 0
+    CENTER = 1
+
+class QUIConfig():
+    @staticmethod
+    def initialize(icon_size = 48, icon_spacer_size=16, preview_bar_icon_size=64):
+        QUIConfig.icon_q_size = QSize(icon_size, icon_size)
+        QUIConfig.icon_spacer_q_size = QSize(icon_spacer_size, icon_spacer_size)
+        QUIConfig.preview_bar_icon_q_size = QSize(preview_bar_icon_size, preview_bar_icon_size)
+
+class ImagePreviewSequenceBar(QFrame):
+    def __init__(self, preview_images_count, icon_size):
+        super().__init__()
+        self.preview_images_count = preview_images_count = max(1, preview_images_count + (preview_images_count % 2 -1) )
+
+        self.icon_size = icon_size
+
+        black_q_img = QImage(np.zeros( (icon_size,icon_size,3) ).data, icon_size, icon_size, 3*icon_size, QImage.Format_RGB888)
+        self.black_q_pixmap = QPixmap.fromImage(black_q_img)
+
+        self.image_containers = [ QLabel() for i in range(preview_images_count)]
+
+        main_frame_l_cont_hl = QGridLayout()
+        main_frame_l_cont_hl.setContentsMargins(0,0,0,0)
+        #main_frame_l_cont_hl.setSpacing(0)
+
+
+
+        for i in range(len(self.image_containers)):
+            q_label = self.image_containers[i]
+            q_label.setScaledContents(True)
+            if i == preview_images_count//2:
+                q_label.setMinimumSize(icon_size+16, icon_size+16 )
+                q_label.setMaximumSize(icon_size+16, icon_size+16 )
+            else:
+                q_label.setMinimumSize(icon_size, icon_size )
+                q_label.setMaximumSize(icon_size, icon_size )
+                opacity_effect = QGraphicsOpacityEffect()
+                opacity_effect.setOpacity(0.5)
+                q_label.setGraphicsEffect(opacity_effect)
+
+            q_label.setSizePolicy (QSizePolicy.Fixed, QSizePolicy.Fixed)
+
+            main_frame_l_cont_hl.addWidget (q_label, 0, i)
+
+        self.setLayout(main_frame_l_cont_hl)
+
+        self.prev_img_conts = self.image_containers[(preview_images_count//2) -1::-1]
+        self.next_img_conts = self.image_containers[preview_images_count//2:]
+
+        self.update_images()
+
+    def get_preview_images_count(self):
+        return self.preview_images_count
+
+    def update_images(self, prev_imgs=None, next_imgs=None):
+        # Fix arrays
+        if prev_imgs is None:
+            prev_imgs = []
+        prev_img_conts_len = len(self.prev_img_conts)
+        prev_q_imgs_len = len(prev_imgs)
+        if prev_q_imgs_len < prev_img_conts_len:
+            for i in range ( prev_img_conts_len - prev_q_imgs_len ):
+                prev_imgs.append(None)
+        elif prev_q_imgs_len > prev_img_conts_len:
+            prev_imgs = prev_imgs[:prev_img_conts_len]
+
+        if next_imgs is None:
+            next_imgs = []
+        next_img_conts_len = len(self.next_img_conts)
+        next_q_imgs_len = len(next_imgs)
+        if next_q_imgs_len < next_img_conts_len:
+            for i in range ( next_img_conts_len - next_q_imgs_len ):
+                next_imgs.append(None)
+        elif next_q_imgs_len > next_img_conts_len:
+            next_imgs = next_imgs[:next_img_conts_len]
+
+        for i,img in enumerate(prev_imgs):
+            self.prev_img_conts[i].setPixmap( QPixmap.fromImage( QImage_from_np(img) ) if img is not None else self.black_q_pixmap )
+
+        for i,img in enumerate(next_imgs):
+            self.next_img_conts[i].setPixmap( QPixmap.fromImage( QImage_from_np(img) ) if img is not None else self.black_q_pixmap )
+
+class ColorScheme():
+    def __init__(self, unselected_color, selected_color, outline_color, outline_width, pt_outline_color, cross_cursor):
+        self.poly_unselected_brush = QBrush(unselected_color)
+        self.poly_selected_brush = QBrush(selected_color)
+
+        self.poly_outline_solid_pen = QPen(outline_color, outline_width, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)
+        self.poly_outline_dot_pen = QPen(outline_color, outline_width, Qt.DotLine, Qt.RoundCap, Qt.RoundJoin)
+
+        self.pt_outline_pen = QPen(pt_outline_color)
+        self.cross_cursor = cross_cursor
+
+class CanvasConfig():
+
+    def __init__(self,
+                 pt_radius=4,
+                 pt_select_radius=8,
+                 color_schemes=None,
+                 **kwargs):
+        self.pt_radius = pt_radius
+        self.pt_select_radius = pt_select_radius
+
+        if color_schemes is None:
+            color_schemes = [
+                    ColorScheme( QColor(192,0,0,alpha=0), QColor(192,0,0,alpha=72), QColor(192,0,0), 2, QColor(255,255,255), QCursorDB.cross_red ),
+                    ColorScheme( QColor(0,192,0,alpha=0), QColor(0,192,0,alpha=72), QColor(0,192,0), 2, QColor(255,255,255), QCursorDB.cross_green ),
+                    ColorScheme( QColor(0,0,192,alpha=0), QColor(0,0,192,alpha=72), QColor(0,0,192), 2, QColor(255,255,255), QCursorDB.cross_blue ),
+                    ]
+        self.color_schemes = color_schemes
+
+class QCanvasControlsLeftBar(QFrame):
+
+    def __init__(self):
+        super().__init__()
+        #==============================================
+        btn_poly_type_include = QToolButton()
+        self.btn_poly_type_include_act = QActionEx( QIconDB.poly_type_include, QStringDB.btn_poly_type_include_tip, shortcut='Q', shortcut_in_tooltip=True, is_checkable=True)
+        btn_poly_type_include.setDefaultAction(self.btn_poly_type_include_act)
+        btn_poly_type_include.setIconSize(QUIConfig.icon_q_size)
+
+        btn_poly_type_exclude = QToolButton()
+        self.btn_poly_type_exclude_act = QActionEx( QIconDB.poly_type_exclude, QStringDB.btn_poly_type_exclude_tip, shortcut='W', shortcut_in_tooltip=True, is_checkable=True)
+        btn_poly_type_exclude.setDefaultAction(self.btn_poly_type_exclude_act)
+        btn_poly_type_exclude.setIconSize(QUIConfig.icon_q_size)
+
+        self.btn_poly_type_act_grp = QActionGroup (self)
+        self.btn_poly_type_act_grp.addAction(self.btn_poly_type_include_act)
+        self.btn_poly_type_act_grp.addAction(self.btn_poly_type_exclude_act)
+        self.btn_poly_type_act_grp.setExclusive(True)
+        #==============================================
+        btn_undo_pt = QToolButton()
+        self.btn_undo_pt_act = QActionEx( QIconDB.undo_pt, QStringDB.btn_undo_pt_tip, shortcut='Ctrl+Z', shortcut_in_tooltip=True, is_auto_repeat=True)
+        btn_undo_pt.setDefaultAction(self.btn_undo_pt_act)
+        btn_undo_pt.setIconSize(QUIConfig.icon_q_size)
+
+        btn_redo_pt = QToolButton()
+        self.btn_redo_pt_act = QActionEx( QIconDB.redo_pt, QStringDB.btn_redo_pt_tip, shortcut='Ctrl+Shift+Z',  shortcut_in_tooltip=True, is_auto_repeat=True)
+        btn_redo_pt.setDefaultAction(self.btn_redo_pt_act)
+        btn_redo_pt.setIconSize(QUIConfig.icon_q_size)
+
+        btn_delete_poly = QToolButton()
+        self.btn_delete_poly_act = QActionEx( QIconDB.delete_poly, QStringDB.btn_delete_poly_tip, shortcut='Delete', shortcut_in_tooltip=True)
+        btn_delete_poly.setDefaultAction(self.btn_delete_poly_act)
+        btn_delete_poly.setIconSize(QUIConfig.icon_q_size)
+        #==============================================
+        btn_pt_edit_mode = QToolButton()
+        self.btn_pt_edit_mode_act = QActionEx( QIconDB.pt_edit_mode, QStringDB.btn_pt_edit_mode_tip, shortcut_in_tooltip=True, is_checkable=True)
+        btn_pt_edit_mode.setDefaultAction(self.btn_pt_edit_mode_act)
+        btn_pt_edit_mode.setIconSize(QUIConfig.icon_q_size)
+        #==============================================
+
+        controls_bar_frame2_l = QVBoxLayout()
+        controls_bar_frame2_l.addWidget ( btn_poly_type_include )
+        controls_bar_frame2_l.addWidget ( btn_poly_type_exclude )
+        controls_bar_frame2 = QFrame()
+        controls_bar_frame2.setFrameShape(QFrame.StyledPanel)
+        controls_bar_frame2.setSizePolicy (QSizePolicy.Fixed, QSizePolicy.Fixed)
+        controls_bar_frame2.setLayout(controls_bar_frame2_l)
+
+        controls_bar_frame3_l = QVBoxLayout()
+        controls_bar_frame3_l.addWidget ( btn_undo_pt )
+        controls_bar_frame3_l.addWidget ( btn_redo_pt )
+        controls_bar_frame3_l.addWidget ( btn_delete_poly )
+        controls_bar_frame3 = QFrame()
+        controls_bar_frame3.setFrameShape(QFrame.StyledPanel)
+        controls_bar_frame3.setSizePolicy (QSizePolicy.Fixed, QSizePolicy.Fixed)
+        controls_bar_frame3.setLayout(controls_bar_frame3_l)
+
+        controls_bar_frame4_l = QVBoxLayout()
+        controls_bar_frame4_l.addWidget ( btn_pt_edit_mode )
+        controls_bar_frame4 = QFrame()
+        controls_bar_frame4.setFrameShape(QFrame.StyledPanel)
+        controls_bar_frame4.setSizePolicy (QSizePolicy.Fixed, QSizePolicy.Fixed)
+        controls_bar_frame4.setLayout(controls_bar_frame4_l)
+
+        controls_bar_l = QVBoxLayout()
+        controls_bar_l.setContentsMargins(0,0,0,0)
+        controls_bar_l.addWidget(controls_bar_frame2)
+        controls_bar_l.addWidget(controls_bar_frame3)
+        controls_bar_l.addWidget(controls_bar_frame4)
+
+        self.setSizePolicy ( QSizePolicy.Fixed, QSizePolicy.Expanding )
+        self.setLayout(controls_bar_l)
+
+class QCanvasControlsRightBar(QFrame):
+
+    def __init__(self):
+        super().__init__()
+        #==============================================
+        btn_poly_color_red = QToolButton()
+        self.btn_poly_color_red_act = QActionEx( QIconDB.poly_color_red, QStringDB.btn_poly_color_red_tip, shortcut='1', shortcut_in_tooltip=True, is_checkable=True)
+        btn_poly_color_red.setDefaultAction(self.btn_poly_color_red_act)
+        btn_poly_color_red.setIconSize(QUIConfig.icon_q_size)
+
+        btn_poly_color_green = QToolButton()
+        self.btn_poly_color_green_act = QActionEx( QIconDB.poly_color_green, QStringDB.btn_poly_color_green_tip, shortcut='2', shortcut_in_tooltip=True, is_checkable=True)
+        btn_poly_color_green.setDefaultAction(self.btn_poly_color_green_act)
+        btn_poly_color_green.setIconSize(QUIConfig.icon_q_size)
+
+        btn_poly_color_blue = QToolButton()
+        self.btn_poly_color_blue_act = QActionEx( QIconDB.poly_color_blue, QStringDB.btn_poly_color_blue_tip, shortcut='3', shortcut_in_tooltip=True, is_checkable=True)
+        btn_poly_color_blue.setDefaultAction(self.btn_poly_color_blue_act)
+        btn_poly_color_blue.setIconSize(QUIConfig.icon_q_size)
+
+        btn_view_baked_mask = QToolButton()
+        self.btn_view_baked_mask_act = QActionEx( QIconDB.view_baked, QStringDB.btn_view_baked_mask_tip, shortcut='4', shortcut_in_tooltip=True, is_checkable=True)
+        btn_view_baked_mask.setDefaultAction(self.btn_view_baked_mask_act)
+        btn_view_baked_mask.setIconSize(QUIConfig.icon_q_size)
+
+        btn_view_xseg_mask = QToolButton()
+        self.btn_view_xseg_mask_act = QActionEx( QIconDB.view_xseg, QStringDB.btn_view_xseg_mask_tip, shortcut='5', shortcut_in_tooltip=True, is_checkable=True)
+        btn_view_xseg_mask.setDefaultAction(self.btn_view_xseg_mask_act)
+        btn_view_xseg_mask.setIconSize(QUIConfig.icon_q_size)
+
+        btn_view_xseg_overlay_mask = QToolButton()
+        self.btn_view_xseg_overlay_mask_act = QActionEx( QIconDB.view_xseg_overlay, QStringDB.btn_view_xseg_overlay_mask_tip, shortcut='`', shortcut_in_tooltip=True, is_checkable=True)
+        btn_view_xseg_overlay_mask.setDefaultAction(self.btn_view_xseg_overlay_mask_act)
+        btn_view_xseg_overlay_mask.setIconSize(QUIConfig.icon_q_size)
+
+        self.btn_poly_color_act_grp = QActionGroup (self)
+        self.btn_poly_color_act_grp.addAction(self.btn_poly_color_red_act)
+        self.btn_poly_color_act_grp.addAction(self.btn_poly_color_green_act)
+        self.btn_poly_color_act_grp.addAction(self.btn_poly_color_blue_act)
+        self.btn_poly_color_act_grp.addAction(self.btn_view_baked_mask_act)
+        self.btn_poly_color_act_grp.addAction(self.btn_view_xseg_mask_act)
+        self.btn_poly_color_act_grp.setExclusive(True)
+        #==============================================
+        btn_view_lock_center = QToolButton()
+        self.btn_view_lock_center_act = QActionEx( QIconDB.view_lock_center, QStringDB.btn_view_lock_center_tip, shortcut_in_tooltip=True, is_checkable=True)
+        btn_view_lock_center.setDefaultAction(self.btn_view_lock_center_act)
+        btn_view_lock_center.setIconSize(QUIConfig.icon_q_size)
+
+        controls_bar_frame2_l = QVBoxLayout()
+        controls_bar_frame2_l.addWidget ( btn_view_xseg_overlay_mask )
+        controls_bar_frame2 = QFrame()
+        controls_bar_frame2.setFrameShape(QFrame.StyledPanel)
+        controls_bar_frame2.setSizePolicy (QSizePolicy.Fixed, QSizePolicy.Fixed)
+        controls_bar_frame2.setLayout(controls_bar_frame2_l)
+        
+        controls_bar_frame1_l = QVBoxLayout()
+        controls_bar_frame1_l.addWidget ( btn_poly_color_red )
+        controls_bar_frame1_l.addWidget ( btn_poly_color_green )
+        controls_bar_frame1_l.addWidget ( btn_poly_color_blue )
+        controls_bar_frame1_l.addWidget ( btn_view_baked_mask )
+        controls_bar_frame1_l.addWidget ( btn_view_xseg_mask )
+        controls_bar_frame1 = QFrame()
+        controls_bar_frame1.setFrameShape(QFrame.StyledPanel)
+        controls_bar_frame1.setSizePolicy (QSizePolicy.Fixed, QSizePolicy.Fixed)
+        controls_bar_frame1.setLayout(controls_bar_frame1_l)
+        
+        controls_bar_frame3_l = QVBoxLayout()
+        controls_bar_frame3_l.addWidget ( btn_view_lock_center )
+        controls_bar_frame3 = QFrame()
+        controls_bar_frame3.setFrameShape(QFrame.StyledPanel)
+        controls_bar_frame3.setSizePolicy (QSizePolicy.Fixed, QSizePolicy.Fixed)
+        controls_bar_frame3.setLayout(controls_bar_frame3_l)
+
+        controls_bar_l = QVBoxLayout()
+        controls_bar_l.setContentsMargins(0,0,0,0)
+        controls_bar_l.addWidget(controls_bar_frame2)
+        controls_bar_l.addWidget(controls_bar_frame1)
+        controls_bar_l.addWidget(controls_bar_frame3)
+        
+        self.setSizePolicy ( QSizePolicy.Fixed, QSizePolicy.Expanding )
+        self.setLayout(controls_bar_l)
+
+class QCanvasOperator(QWidget):
+    def __init__(self, cbar):
+        super().__init__()
+        self.cbar = cbar
+
+        self.set_cbar_disabled()
+
+        self.cbar.btn_poly_color_red_act.triggered.connect ( lambda : self.set_color_scheme_id(0) )
+        self.cbar.btn_poly_color_green_act.triggered.connect ( lambda : self.set_color_scheme_id(1) )
+        self.cbar.btn_poly_color_blue_act.triggered.connect ( lambda : self.set_color_scheme_id(2) )
+        self.cbar.btn_view_baked_mask_act.triggered.connect ( lambda : self.set_op_mode(OpMode.VIEW_BAKED) )
+        self.cbar.btn_view_xseg_mask_act.triggered.connect ( lambda : self.set_op_mode(OpMode.VIEW_XSEG_MASK) )
+
+        self.cbar.btn_view_xseg_overlay_mask_act.toggled.connect ( lambda is_checked: self.update() )
+
+        self.cbar.btn_poly_type_include_act.triggered.connect ( lambda : self.set_poly_include_type(SegIEPolyType.INCLUDE) )
+        self.cbar.btn_poly_type_exclude_act.triggered.connect ( lambda : self.set_poly_include_type(SegIEPolyType.EXCLUDE) )
+
+        self.cbar.btn_undo_pt_act.triggered.connect ( lambda : self.action_undo_pt() )
+        self.cbar.btn_redo_pt_act.triggered.connect ( lambda : self.action_redo_pt() )
+
+        self.cbar.btn_delete_poly_act.triggered.connect ( lambda : self.action_delete_poly() )
+
+        self.cbar.btn_pt_edit_mode_act.toggled.connect ( lambda is_checked: self.set_pt_edit_mode( PTEditMode.ADD_DEL if is_checked else PTEditMode.MOVE ) )
+        self.cbar.btn_view_lock_center_act.toggled.connect ( lambda is_checked: self.set_view_lock( ViewLock.CENTER if is_checked else ViewLock.NONE ) )
+
+        self.mouse_in_widget = False
+
+        QXMainWindow.inst.add_keyPressEvent_listener ( self.on_keyPressEvent )
+        QXMainWindow.inst.add_keyReleaseEvent_listener ( self.on_keyReleaseEvent )
+
+        self.qp = QPainter()
+        self.initialized = False
+        self.last_state = None
+
+    def initialize(self, img, img_look_pt=None, view_scale=None, ie_polys=None, xseg_mask=None, canvas_config=None ):
+        q_img = self.q_img = QImage_from_np(img)
+        self.img_pixmap = QPixmap.fromImage(q_img)
+
+        self.xseg_mask_pixmap = None
+        self.xseg_overlay_mask_pixmap = None
+        if xseg_mask is not None:
+            h,w,c = img.shape
+            xseg_mask = cv2.resize(xseg_mask, (w,h), interpolation=cv2.INTER_CUBIC)
+            xseg_mask = imagelib.normalize_channels(xseg_mask, 1)
+            xseg_img = img.astype(np.float32)/255.0
+            xseg_overlay_mask = xseg_img*(1-xseg_mask)*0.5 + xseg_img*xseg_mask
+            xseg_overlay_mask = np.clip(xseg_overlay_mask*255, 0, 255).astype(np.uint8)
+            xseg_mask = np.clip(xseg_mask*255, 0, 255).astype(np.uint8)
+            self.xseg_mask_pixmap = QPixmap.fromImage(QImage_from_np(xseg_mask))
+            self.xseg_overlay_mask_pixmap = QPixmap.fromImage(QImage_from_np(xseg_overlay_mask))
+
+        self.img_size = QSize_to_np (self.img_pixmap.size())
+
+        self.img_look_pt = img_look_pt
+        self.view_scale = view_scale
+
+        if ie_polys is None:
+            ie_polys = SegIEPolys()
+        self.ie_polys = ie_polys
+
+        if canvas_config is None:
+            canvas_config = CanvasConfig()
+        self.canvas_config = canvas_config
+
+        # UI init
+        self.set_cbar_disabled()
+        self.cbar.btn_poly_color_act_grp.setDisabled(False)
+        self.cbar.btn_view_xseg_overlay_mask_act.setDisabled(False)
+        self.cbar.btn_poly_type_act_grp.setDisabled(False)
+
+        # Initial vars
+        self.current_cursor = None
+        self.mouse_hull_poly = None
+        self.mouse_wire_poly = None
+        self.drag_type = DragType.NONE
+        self.mouse_cli_pt = np.zeros((2,), np.float32 )
+
+        # Initial state
+        self.set_op_mode(OpMode.NONE)
+        self.set_color_scheme_id(1)
+        self.set_poly_include_type(SegIEPolyType.INCLUDE)
+        self.set_pt_edit_mode(PTEditMode.MOVE)
+        self.set_view_lock(ViewLock.NONE)
+
+        # Apply last state
+        if self.last_state is not None:
+            self.set_color_scheme_id(self.last_state.color_scheme_id)
+            if self.last_state.op_mode is not None:
+                self.set_op_mode(self.last_state.op_mode)
+
+        self.initialized = True
+
+        self.setMouseTracking(True)
+        self.update_cursor()
+        self.update()
+
+
+    def finalize(self):
+        if self.initialized:
+            if self.op_mode == OpMode.DRAW_PTS:
+                self.set_op_mode(OpMode.EDIT_PTS)
+
+            self.last_state = sn(op_mode = self.op_mode if self.op_mode in [OpMode.VIEW_BAKED, OpMode.VIEW_XSEG_MASK] else None,
+                                 color_scheme_id = self.color_scheme_id)
+
+            self.img_pixmap = None
+            self.update_cursor(is_finalize=True)
+            self.setMouseTracking(False)
+            self.setFocusPolicy(Qt.NoFocus)
+            self.set_cbar_disabled()
+            self.initialized = False
+            self.update()
+
+    # ====================================================================================
+    # ====================================================================================
+    # ====================================== GETTERS =====================================
+    # ====================================================================================
+    # ====================================================================================
+    def is_initialized(self):
+        return self.initialized
+
+    def get_ie_polys(self):
+        return self.ie_polys
+
+    def get_cli_center_pt(self):
+        return np.round(QSize_to_np(self.size())/2.0)
+
+    def get_img_look_pt(self):
+        img_look_pt = self.img_look_pt
+        if img_look_pt is None:
+            img_look_pt = self.img_size / 2
+        return img_look_pt
+
+    def get_view_scale(self):
+        view_scale = self.view_scale
+        if view_scale is None:
+            # Calc as scale to fit
+            min_cli_size = np.min(QSize_to_np(self.size()))
+            max_img_size = np.max(self.img_size)
+            view_scale =  min_cli_size / max_img_size
+
+        return view_scale
+
+    def get_current_color_scheme(self):
+        return self.canvas_config.color_schemes[self.color_scheme_id]
+
+    def get_poly_pt_id_under_pt(self, poly, cli_pt):
+        w = np.argwhere ( npla.norm ( cli_pt - self.img_to_cli_pt( poly.get_pts() ), axis=1 )  <= self.canvas_config.pt_select_radius )
+        return None if len(w) == 0 else w[-1][0]
+
+    def get_poly_edge_id_pt_under_pt(self, poly, cli_pt):
+        cli_pts = self.img_to_cli_pt(poly.get_pts())
+        if len(cli_pts) >= 3:
+            edge_dists, projs = sd.dist_to_edges(cli_pts, cli_pt, is_closed=True)
+            edge_id = np.argmin(edge_dists)
+            dist = edge_dists[edge_id]
+            pt = projs[edge_id]
+            if dist <= self.canvas_config.pt_select_radius:
+                return edge_id, pt
+        return None, None
+
+    def get_poly_by_pt_near_wire(self, cli_pt):
+        pt_select_radius = self.canvas_config.pt_select_radius
+
+        for poly in reversed(self.ie_polys.get_polys()):
+            pts = poly.get_pts()
+            if len(pts) >= 3:
+                cli_pts = self.img_to_cli_pt(pts)
+
+                edge_dists, _ = sd.dist_to_edges(cli_pts, cli_pt, is_closed=True)
+
+                if np.min(edge_dists) <= pt_select_radius or \
+                   any( npla.norm ( cli_pt - cli_pts, axis=1 ) <= pt_select_radius ):
+                    return poly
+        return None
+
+    def get_poly_by_pt_in_hull(self, cli_pos):
+        img_pos = self.cli_to_img_pt(cli_pos)
+
+        for poly in reversed(self.ie_polys.get_polys()):
+            pts = poly.get_pts()
+            if len(pts) >= 3:
+                if cv2.pointPolygonTest( pts, tuple(img_pos), False) >= 0:
+                    return poly
+
+        return None
+
+    def img_to_cli_pt(self, p):
+        return (p - self.get_img_look_pt()) * self.get_view_scale() + self.get_cli_center_pt()# QSize_to_np(self.size())/2.0
+
+    def cli_to_img_pt(self, p):
+        return (p - self.get_cli_center_pt() ) / self.get_view_scale() + self.get_img_look_pt()
+
+    def img_to_cli_rect(self, rect):
+        tl = QPoint_to_np(rect.topLeft())
+        xy = self.img_to_cli_pt(tl)
+        xy2 = self.img_to_cli_pt(tl + QSize_to_np(rect.size()) ) - xy
+        return QRect ( *xy.astype(np.int), *xy2.astype(np.int) )
+
+    # ====================================================================================
+    # ====================================================================================
+    # ====================================== SETTERS =====================================
+    # ====================================================================================
+    # ====================================================================================
+    def set_op_mode(self, op_mode, op_poly=None):
+        if not hasattr(self,'op_mode'):
+            self.op_mode = None
+            self.op_poly = None
+
+        if self.op_mode != op_mode:
+            # Finalize prev mode
+            if self.op_mode == OpMode.NONE:
+                self.cbar.btn_poly_type_act_grp.setDisabled(True)
+            elif self.op_mode == OpMode.DRAW_PTS:
+                self.cbar.btn_undo_pt_act.setDisabled(True)
+                self.cbar.btn_redo_pt_act.setDisabled(True)
+                self.cbar.btn_view_lock_center_act.setDisabled(True)
+                # Reset view_lock when exit from DRAW_PTS
+                self.set_view_lock(ViewLock.NONE)
+                # Remove unfinished poly
+                if self.op_poly.get_pts_count() < 3:
+                    self.ie_polys.remove_poly(self.op_poly)
+
+            elif self.op_mode == OpMode.EDIT_PTS:
+                self.cbar.btn_pt_edit_mode_act.setDisabled(True)
+                self.cbar.btn_delete_poly_act.setDisabled(True)
+                # Reset pt_edit_move when exit from EDIT_PTS
+                self.set_pt_edit_mode(PTEditMode.MOVE)
+            elif self.op_mode == OpMode.VIEW_BAKED:
+                self.cbar.btn_view_baked_mask_act.setChecked(False)
+            elif self.op_mode == OpMode.VIEW_XSEG_MASK:
+                self.cbar.btn_view_xseg_mask_act.setChecked(False)
+
+            self.op_mode = op_mode
+
+            # Initialize new mode
+            if op_mode == OpMode.NONE:
+                self.cbar.btn_poly_type_act_grp.setDisabled(False)
+            elif op_mode == OpMode.DRAW_PTS:
+                self.cbar.btn_undo_pt_act.setDisabled(False)
+                self.cbar.btn_redo_pt_act.setDisabled(False)
+                self.cbar.btn_view_lock_center_act.setDisabled(False)
+            elif op_mode == OpMode.EDIT_PTS:
+                self.cbar.btn_pt_edit_mode_act.setDisabled(False)
+                self.cbar.btn_delete_poly_act.setDisabled(False)
+            elif op_mode == OpMode.VIEW_BAKED:
+                self.cbar.btn_view_baked_mask_act.setChecked(True )
+                n = QImage_to_np ( self.q_img ).astype(np.float32) / 255.0
+                h,w,c = n.shape
+                mask = np.zeros( (h,w,1), dtype=np.float32 )
+                self.ie_polys.overlay_mask(mask)
+                n = (mask*255).astype(np.uint8)
+                self.img_baked_pixmap = QPixmap.fromImage(QImage_from_np(n))
+            elif op_mode == OpMode.VIEW_XSEG_MASK:
+                self.cbar.btn_view_xseg_mask_act.setChecked(True)
+
+            if op_mode in [OpMode.DRAW_PTS, OpMode.EDIT_PTS]:
+                self.mouse_op_poly_pt_id = None
+                self.mouse_op_poly_edge_id = None
+                self.mouse_op_poly_edge_id_pt = None
+
+            self.op_poly = op_poly
+            if op_poly is not None:
+                self.update_mouse_info()
+
+            self.update_cursor()
+            self.update()
+
+    def set_pt_edit_mode(self, pt_edit_mode):
+        if not hasattr(self, 'pt_edit_mode') or self.pt_edit_mode != pt_edit_mode:
+            self.pt_edit_mode = pt_edit_mode
+            self.update_cursor()
+            self.update()
+        self.cbar.btn_pt_edit_mode_act.setChecked( self.pt_edit_mode == PTEditMode.ADD_DEL )
+
+    def set_view_lock(self, view_lock):
+        if not hasattr(self, 'view_lock') or self.view_lock != view_lock:
+            if hasattr(self, 'view_lock') and self.view_lock != view_lock:
+                if view_lock == ViewLock.CENTER:
+                    self.img_look_pt = self.mouse_img_pt
+                    QCursor.setPos ( self.mapToGlobal( QPoint_from_np(self.img_to_cli_pt(self.img_look_pt)) ))
+
+            self.view_lock = view_lock
+            self.update()
+        self.cbar.btn_view_lock_center_act.setChecked( self.view_lock == ViewLock.CENTER )
+
+    def set_cbar_disabled(self):
+        self.cbar.btn_delete_poly_act.setDisabled(True)
+        self.cbar.btn_undo_pt_act.setDisabled(True)
+        self.cbar.btn_redo_pt_act.setDisabled(True)
+        self.cbar.btn_pt_edit_mode_act.setDisabled(True)
+        self.cbar.btn_view_lock_center_act.setDisabled(True)
+        self.cbar.btn_poly_color_act_grp.setDisabled(True)
+        self.cbar.btn_view_xseg_overlay_mask_act.setDisabled(True)
+        self.cbar.btn_poly_type_act_grp.setDisabled(True)
+
+
+    def set_color_scheme_id(self, id):
+        if self.op_mode == OpMode.VIEW_BAKED or self.op_mode == OpMode.VIEW_XSEG_MASK:
+            self.set_op_mode(OpMode.NONE)
+
+        if not hasattr(self, 'color_scheme_id') or self.color_scheme_id != id:
+            self.color_scheme_id = id
+            self.update_cursor()
+            self.update()
+
+        if self.color_scheme_id == 0:
+            self.cbar.btn_poly_color_red_act.setChecked( True )
+        elif self.color_scheme_id == 1:
+            self.cbar.btn_poly_color_green_act.setChecked( True )
+        elif self.color_scheme_id == 2:
+            self.cbar.btn_poly_color_blue_act.setChecked( True )
+
+    def set_poly_include_type(self, poly_include_type):
+        if not hasattr(self, 'poly_include_type' ) or \
+           ( self.poly_include_type != poly_include_type and \
+             self.op_mode in [OpMode.NONE, OpMode.EDIT_PTS] ):
+            self.poly_include_type = poly_include_type
+            self.update()
+        self.cbar.btn_poly_type_include_act.setChecked(self.poly_include_type == SegIEPolyType.INCLUDE)
+        self.cbar.btn_poly_type_exclude_act.setChecked(self.poly_include_type == SegIEPolyType.EXCLUDE)
+
+    # ====================================================================================
+    # ====================================================================================
+    # ====================================== METHODS =====================================
+    # ====================================================================================
+    # ====================================================================================
+
+    def update_cursor(self, is_finalize=False):
+        if not self.initialized:
+            return
+
+        if not self.mouse_in_widget or is_finalize:
+            if self.current_cursor is not None:
+                QApplication.restoreOverrideCursor()
+                self.current_cursor = None
+        else:
+            color_cc = self.get_current_color_scheme().cross_cursor
+            nc = Qt.ArrowCursor
+
+            if self.drag_type == DragType.IMAGE_LOOK:
+                nc = Qt.ClosedHandCursor
+            else:
+
+                if self.op_mode == OpMode.NONE:
+                    nc = color_cc
+                    if self.mouse_wire_poly is not None:
+                        nc = Qt.PointingHandCursor
+
+                elif self.op_mode == OpMode.DRAW_PTS:
+                    nc = color_cc
+                elif self.op_mode == OpMode.EDIT_PTS:
+                    nc = Qt.ArrowCursor
+
+                    if self.mouse_op_poly_pt_id is not None:
+                        nc = Qt.PointingHandCursor
+
+                    if self.pt_edit_mode == PTEditMode.ADD_DEL:
+
+                        if self.mouse_op_poly_edge_id is not None and \
+                        self.mouse_op_poly_pt_id is None:
+                            nc = color_cc
+            if self.current_cursor != nc:
+                if self.current_cursor is None:
+                    QApplication.setOverrideCursor(nc)
+                else:
+                    QApplication.changeOverrideCursor(nc)
+                self.current_cursor = nc
+
+    def update_mouse_info(self, mouse_cli_pt=None):
+        """
+        Update selected polys/edges/points by given mouse position
+        """
+        if mouse_cli_pt is not None:
+            self.mouse_cli_pt = mouse_cli_pt.astype(np.float32)
+
+        self.mouse_img_pt = self.cli_to_img_pt(self.mouse_cli_pt)
+
+        new_mouse_hull_poly = self.get_poly_by_pt_in_hull(self.mouse_cli_pt)
+
+        if self.mouse_hull_poly != new_mouse_hull_poly:
+            self.mouse_hull_poly = new_mouse_hull_poly
+            self.update_cursor()
+            self.update()
+
+        new_mouse_wire_poly = self.get_poly_by_pt_near_wire(self.mouse_cli_pt)
+
+        if self.mouse_wire_poly != new_mouse_wire_poly:
+            self.mouse_wire_poly = new_mouse_wire_poly
+            self.update_cursor()
+            self.update()
+
+        if self.op_mode in [OpMode.DRAW_PTS, OpMode.EDIT_PTS]:
+            new_mouse_op_poly_pt_id = self.get_poly_pt_id_under_pt (self.op_poly, self.mouse_cli_pt)
+            if self.mouse_op_poly_pt_id != new_mouse_op_poly_pt_id:
+                self.mouse_op_poly_pt_id = new_mouse_op_poly_pt_id
+                self.update_cursor()
+                self.update()
+
+            new_mouse_op_poly_edge_id,\
+            new_mouse_op_poly_edge_id_pt = self.get_poly_edge_id_pt_under_pt (self.op_poly, self.mouse_cli_pt)
+            if self.mouse_op_poly_edge_id != new_mouse_op_poly_edge_id:
+                self.mouse_op_poly_edge_id = new_mouse_op_poly_edge_id
+                self.update_cursor()
+                self.update()
+
+            if (self.mouse_op_poly_edge_id_pt.__class__ != new_mouse_op_poly_edge_id_pt.__class__) or \
+               (isinstance(self.mouse_op_poly_edge_id_pt, np.ndarray) and \
+                all(self.mouse_op_poly_edge_id_pt != new_mouse_op_poly_edge_id_pt)):
+
+                self.mouse_op_poly_edge_id_pt = new_mouse_op_poly_edge_id_pt
+                self.update_cursor()
+                self.update()
+
+
+    def action_undo_pt(self):
+        if self.drag_type == DragType.NONE:
+            if self.op_mode == OpMode.DRAW_PTS:
+                if self.op_poly.undo() == 0:
+                    self.ie_polys.remove_poly (self.op_poly)
+                    self.set_op_mode(OpMode.NONE)
+                self.update()
+
+    def action_redo_pt(self):
+        if self.drag_type == DragType.NONE:
+            if self.op_mode == OpMode.DRAW_PTS:
+                self.op_poly.redo()
+                self.update()
+
+    def action_delete_poly(self):
+        if self.op_mode == OpMode.EDIT_PTS and \
+            self.drag_type == DragType.NONE and \
+            self.pt_edit_mode == PTEditMode.MOVE:
+            # Delete current poly
+            self.ie_polys.remove_poly (self.op_poly)
+            self.set_op_mode(OpMode.NONE)
+
+    # ====================================================================================
+    # ====================================================================================
+    # ================================== OVERRIDE QT METHODS =============================
+    # ====================================================================================
+    # ====================================================================================
+    def on_keyPressEvent(self, ev):
+        if not self.initialized:
+            return
+        key = ev.key()
+        key_mods = int(ev.modifiers())
+        if self.op_mode == OpMode.DRAW_PTS:
+            self.set_view_lock(ViewLock.CENTER if key_mods == Qt.ShiftModifier else ViewLock.NONE )
+        elif self.op_mode == OpMode.EDIT_PTS:
+            self.set_pt_edit_mode(PTEditMode.ADD_DEL if key_mods == Qt.ControlModifier else PTEditMode.MOVE )
+
+    def on_keyReleaseEvent(self, ev):
+        if not self.initialized:
+            return
+        key = ev.key()
+        key_mods = int(ev.modifiers())
+        if self.op_mode == OpMode.DRAW_PTS:
+            self.set_view_lock(ViewLock.CENTER if key_mods == Qt.ShiftModifier else ViewLock.NONE )
+        elif self.op_mode == OpMode.EDIT_PTS:
+            self.set_pt_edit_mode(PTEditMode.ADD_DEL if key_mods == Qt.ControlModifier else PTEditMode.MOVE )
+
+    def enterEvent(self, ev):
+        super().enterEvent(ev)
+        self.mouse_in_widget = True
+        self.update_cursor()
+
+    def leaveEvent(self, ev):
+        super().leaveEvent(ev)
+        self.mouse_in_widget = False
+        self.update_cursor()
+
+    def mousePressEvent(self, ev):
+        super().mousePressEvent(ev)
+        if not self.initialized:
+            return
+
+        self.update_mouse_info(QPoint_to_np(ev.pos()))
+
+        btn = ev.button()
+
+        if btn == Qt.LeftButton:
+            if self.op_mode == OpMode.NONE:
+                # Clicking in NO OPERATION mode
+                if self.mouse_wire_poly is not None:
+                    # Click on wire on any poly -> switch to EDIT_MODE
+                    self.set_op_mode(OpMode.EDIT_PTS, op_poly=self.mouse_wire_poly)
+                else:
+                    # Click on empty space -> create new poly with one point
+                    new_poly = self.ie_polys.add_poly(self.poly_include_type)
+                    self.ie_polys.sort()
+                    new_poly.add_pt(*self.mouse_img_pt)
+                    self.set_op_mode(OpMode.DRAW_PTS, op_poly=new_poly )
+
+            elif self.op_mode == OpMode.DRAW_PTS:
+                # Clicking in DRAW_PTS mode
+                if len(self.op_poly.get_pts()) >= 3 and self.mouse_op_poly_pt_id == 0:
+                    # Click on first point -> close poly and switch to edit mode
+                    self.set_op_mode(OpMode.EDIT_PTS, op_poly=self.op_poly)
+                else:
+                    # Click on empty space -> add point to current poly
+                    self.op_poly.add_pt(*self.mouse_img_pt)
+                    self.update()
+
+            elif self.op_mode == OpMode.EDIT_PTS:
+                # Clicking in EDIT_PTS mode
+
+                if self.mouse_op_poly_pt_id is not None:
+                    # Click on point of op_poly
+                    if self.pt_edit_mode == PTEditMode.ADD_DEL:
+                        # in mode 'delete point'
+                        self.op_poly.remove_pt(self.mouse_op_poly_pt_id)
+                        if self.op_poly.get_pts_count() < 3:
+                            # not enough points after delete -> remove poly
+                            self.ie_polys.remove_poly (self.op_poly)
+                            self.set_op_mode(OpMode.NONE)
+                        self.update()
+
+                    elif self.drag_type == DragType.NONE:
+                        # otherwise -> start drag
+                        self.drag_type = DragType.POLY_PT
+                        self.drag_cli_pt     = self.mouse_cli_pt
+                        self.drag_poly_pt_id = self.mouse_op_poly_pt_id
+                        self.drag_poly_pt    = self.op_poly.get_pts()[ self.drag_poly_pt_id ]
+                elif self.mouse_op_poly_edge_id is not None:
+                    # Click on edge of op_poly
+                    if self.pt_edit_mode == PTEditMode.ADD_DEL:
+                        # in mode 'insert new point'
+                        edge_img_pt = self.cli_to_img_pt(self.mouse_op_poly_edge_id_pt)
+                        self.op_poly.insert_pt (self.mouse_op_poly_edge_id+1, edge_img_pt)
+                        self.update()
+                    else:
+                        # Otherwise do nothing
+                        pass
+                else:
+                    # other cases -> unselect poly
+                    self.set_op_mode(OpMode.NONE)
+
+        elif btn == Qt.MiddleButton:
+            if self.drag_type == DragType.NONE:
+                # Start image drag
+                self.drag_type = DragType.IMAGE_LOOK
+                self.drag_cli_pt = self.mouse_cli_pt
+                self.drag_img_look_pt = self.get_img_look_pt()
+                self.update_cursor()
+
+
+    def mouseReleaseEvent(self, ev):
+        super().mouseReleaseEvent(ev)
+        if not self.initialized:
+            return
+
+        self.update_mouse_info(QPoint_to_np(ev.pos()))
+
+        btn = ev.button()
+
+        if btn == Qt.LeftButton:
+            if self.op_mode == OpMode.EDIT_PTS:
+                if self.drag_type == DragType.POLY_PT:
+                    self.drag_type = DragType.NONE
+                    self.update()
+
+        elif btn == Qt.MiddleButton:
+            if self.drag_type == DragType.IMAGE_LOOK:
+                self.drag_type = DragType.NONE
+                self.update_cursor()
+                self.update()
+
+    def mouseMoveEvent(self, ev):
+        super().mouseMoveEvent(ev)
+        if not self.initialized:
+            return
+
+        prev_mouse_cli_pt = self.mouse_cli_pt
+        self.update_mouse_info(QPoint_to_np(ev.pos()))
+
+        if self.view_lock == ViewLock.CENTER:
+            if npla.norm(self.mouse_cli_pt - prev_mouse_cli_pt) >= 1:
+                self.img_look_pt = self.mouse_img_pt
+                QCursor.setPos ( self.mapToGlobal( QPoint_from_np(self.img_to_cli_pt(self.img_look_pt)) ))
+            self.update()
+
+        if self.drag_type == DragType.IMAGE_LOOK:
+            delta_pt = self.cli_to_img_pt(self.mouse_cli_pt) - self.cli_to_img_pt(self.drag_cli_pt)
+            self.img_look_pt = self.drag_img_look_pt - delta_pt
+            self.update()
+
+        if self.op_mode == OpMode.DRAW_PTS:
+            self.update()
+        elif self.op_mode == OpMode.EDIT_PTS:
+            if self.drag_type == DragType.POLY_PT:
+                delta_pt = self.cli_to_img_pt(self.mouse_cli_pt) - self.cli_to_img_pt(self.drag_cli_pt)
+                self.op_poly.set_point(self.drag_poly_pt_id, self.drag_poly_pt + delta_pt)
+                self.update()
+
+    def wheelEvent(self, ev):
+        super().wheelEvent(ev)
+
+        if not self.initialized:
+            return
+
+        mods = int(ev.modifiers())
+        delta = ev.angleDelta()
+
+        cli_pt = QPoint_to_np(ev.pos())
+
+        if self.drag_type == DragType.NONE:
+            sign = np.sign( delta.y() )
+            prev_img_pos = self.cli_to_img_pt (cli_pt)
+            delta_scale = sign*0.2 + sign * self.get_view_scale() / 10.0
+            self.view_scale = np.clip(self.get_view_scale() + delta_scale, 1.0, 20.0)
+            new_img_pos = self.cli_to_img_pt (cli_pt)
+            if sign > 0:
+                self.img_look_pt = self.get_img_look_pt() + (prev_img_pos-new_img_pos)#*1.5
+            else:
+                QCursor.setPos ( self.mapToGlobal(QPoint_from_np(self.img_to_cli_pt(prev_img_pos))) )
+            self.update()
+
+    def paintEvent(self, event):
+        super().paintEvent(event)
+        if not self.initialized:
+            return
+
+        qp = self.qp
+        qp.begin(self)
+        qp.setRenderHint(QPainter.Antialiasing)
+        qp.setRenderHint(QPainter.HighQualityAntialiasing)
+        qp.setRenderHint(QPainter.SmoothPixmapTransform)
+
+        src_rect = QRect(0, 0, *self.img_size)
+        dst_rect = self.img_to_cli_rect( src_rect )
+
+        if self.op_mode == OpMode.VIEW_BAKED:
+            qp.drawPixmap(dst_rect, self.img_baked_pixmap, src_rect)
+        elif self.op_mode == OpMode.VIEW_XSEG_MASK:
+            if self.xseg_mask_pixmap is not None:
+                qp.drawPixmap(dst_rect, self.xseg_mask_pixmap, src_rect)
+        else:
+            if self.cbar.btn_view_xseg_overlay_mask_act.isChecked() and \
+               self.xseg_overlay_mask_pixmap is not None:
+                qp.drawPixmap(dst_rect, self.xseg_overlay_mask_pixmap, src_rect)
+            elif self.img_pixmap is not None:
+                qp.drawPixmap(dst_rect, self.img_pixmap, src_rect)
+
+            polys = self.ie_polys.get_polys()
+            polys_len = len(polys)
+
+            color_scheme = self.get_current_color_scheme()
+
+            pt_rad = self.canvas_config.pt_radius
+            pt_rad_x2 = pt_rad*2
+
+            pt_select_radius = self.canvas_config.pt_select_radius
+
+            op_mode = self.op_mode
+            op_poly = self.op_poly
+
+            for i,poly in enumerate(polys):
+
+                selected_pt_path = QPainterPath()
+                poly_line_path = QPainterPath()
+                pts_line_path = QPainterPath()
+
+                pt_remove_cli_pt = None
+                poly_pts = poly.get_pts()
+                for pt_id, img_pt in enumerate(poly_pts):
+                    cli_pt = self.img_to_cli_pt(img_pt)
+                    q_cli_pt = QPoint_from_np(cli_pt)
+
+                    if pt_id == 0:
+                        poly_line_path.moveTo(q_cli_pt)
+                    else:
+                        poly_line_path.lineTo(q_cli_pt)
+
+
+                    if poly == op_poly:
+                        if self.op_mode == OpMode.DRAW_PTS or \
+                            (self.op_mode == OpMode.EDIT_PTS and \
+                            (self.pt_edit_mode == PTEditMode.MOVE) or \
+                            (self.pt_edit_mode == PTEditMode.ADD_DEL and self.mouse_op_poly_pt_id == pt_id) \
+                            ):
+                            pts_line_path.moveTo( QPoint_from_np(cli_pt + np.float32([0,-pt_rad])) )
+                            pts_line_path.lineTo( QPoint_from_np(cli_pt + np.float32([0,pt_rad])) )
+                            pts_line_path.moveTo( QPoint_from_np(cli_pt + np.float32([-pt_rad,0])) )
+                            pts_line_path.lineTo( QPoint_from_np(cli_pt + np.float32([pt_rad,0])) )
+
+                        if (self.op_mode == OpMode.EDIT_PTS and \
+                            self.pt_edit_mode == PTEditMode.ADD_DEL and \
+                            self.mouse_op_poly_pt_id == pt_id):
+                            pt_remove_cli_pt = cli_pt
+
+                        if self.op_mode == OpMode.DRAW_PTS and \
+                            len(op_poly.get_pts()) >= 3 and pt_id == 0 and self.mouse_op_poly_pt_id == pt_id:
+                            # Circle around poly point
+                            selected_pt_path.addEllipse(q_cli_pt, pt_rad_x2, pt_rad_x2)
+
+
+                if poly == op_poly:
+                    if op_mode == OpMode.DRAW_PTS:
+                        # Line from last point to mouse
+                        poly_line_path.lineTo( QPoint_from_np(self.mouse_cli_pt) )
+
+                    if self.mouse_op_poly_pt_id is not None:
+                        pass
+
+                    if self.mouse_op_poly_edge_id_pt is not None:
+                        if self.pt_edit_mode == PTEditMode.ADD_DEL and self.mouse_op_poly_pt_id is None:
+                            # Ready to insert point on edge
+                            m_cli_pt = self.mouse_op_poly_edge_id_pt
+                            pts_line_path.moveTo( QPoint_from_np(m_cli_pt + np.float32([0,-pt_rad])) )
+                            pts_line_path.lineTo( QPoint_from_np(m_cli_pt + np.float32([0,pt_rad])) )
+                            pts_line_path.moveTo( QPoint_from_np(m_cli_pt + np.float32([-pt_rad,0])) )
+                            pts_line_path.lineTo( QPoint_from_np(m_cli_pt + np.float32([pt_rad,0])) )
+
+                if len(poly_pts) >= 2:
+                    # Closing poly line
+                    poly_line_path.lineTo( QPoint_from_np(self.img_to_cli_pt(poly_pts[0])) )
+
+                # Draw calls
+                qp.setPen(color_scheme.pt_outline_pen)
+                qp.setBrush(QBrush())
+                qp.drawPath(selected_pt_path)
+
+                qp.setPen(color_scheme.poly_outline_solid_pen)
+                qp.setBrush(QBrush())
+                qp.drawPath(pts_line_path)
+
+                if poly.get_type() == SegIEPolyType.INCLUDE:
+                    qp.setPen(color_scheme.poly_outline_solid_pen)
+                else:
+                    qp.setPen(color_scheme.poly_outline_dot_pen)
+
+                qp.setBrush(color_scheme.poly_unselected_brush)
+                if op_mode == OpMode.NONE:
+                    if poly == self.mouse_wire_poly:
+                        qp.setBrush(color_scheme.poly_selected_brush)
+                #else:
+                #    if poly == op_poly:
+                #        qp.setBrush(color_scheme.poly_selected_brush)
+
+                qp.drawPath(poly_line_path)
+
+                if pt_remove_cli_pt is not None:
+                    qp.setPen(color_scheme.poly_outline_solid_pen)
+                    qp.setBrush(QBrush())
+
+                    qp.drawLine( *(pt_remove_cli_pt + np.float32([-pt_rad_x2,-pt_rad_x2])), *(pt_remove_cli_pt + np.float32([pt_rad_x2,pt_rad_x2])) )
+                    qp.drawLine( *(pt_remove_cli_pt + np.float32([-pt_rad_x2,pt_rad_x2])), *(pt_remove_cli_pt + np.float32([pt_rad_x2,-pt_rad_x2])) )
+
+        qp.end()
+
+class QCanvas(QFrame):
+    def __init__(self):
+        super().__init__()
+
+        self.canvas_control_left_bar = QCanvasControlsLeftBar()
+        self.canvas_control_right_bar = QCanvasControlsRightBar()
+
+        cbar = sn( btn_poly_color_red_act   = self.canvas_control_right_bar.btn_poly_color_red_act,
+                   btn_poly_color_green_act = self.canvas_control_right_bar.btn_poly_color_green_act,
+                   btn_poly_color_blue_act  = self.canvas_control_right_bar.btn_poly_color_blue_act,
+                   btn_view_baked_mask_act  = self.canvas_control_right_bar.btn_view_baked_mask_act,
+                   btn_view_xseg_mask_act  = self.canvas_control_right_bar.btn_view_xseg_mask_act,
+                   btn_view_xseg_overlay_mask_act  = self.canvas_control_right_bar.btn_view_xseg_overlay_mask_act,
+                   btn_poly_color_act_grp = self.canvas_control_right_bar.btn_poly_color_act_grp,
+                   btn_view_lock_center_act = self.canvas_control_right_bar.btn_view_lock_center_act,
+
+                   btn_poly_type_include_act = self.canvas_control_left_bar.btn_poly_type_include_act,
+                   btn_poly_type_exclude_act = self.canvas_control_left_bar.btn_poly_type_exclude_act,
+                   btn_poly_type_act_grp = self.canvas_control_left_bar.btn_poly_type_act_grp,
+                   btn_undo_pt_act = self.canvas_control_left_bar.btn_undo_pt_act,
+                   btn_redo_pt_act = self.canvas_control_left_bar.btn_redo_pt_act,
+                   btn_delete_poly_act = self.canvas_control_left_bar.btn_delete_poly_act,
+                   btn_pt_edit_mode_act = self.canvas_control_left_bar.btn_pt_edit_mode_act )
+
+        self.op = QCanvasOperator(cbar)
+        self.l = QHBoxLayout()
+        self.l.setContentsMargins(0,0,0,0)
+        self.l.addWidget(self.canvas_control_left_bar)
+        self.l.addWidget(self.op)
+        self.l.addWidget(self.canvas_control_right_bar)
+        self.setLayout(self.l)
+
+class LoaderQSubprocessor(QSubprocessor):
+    def __init__(self, image_paths, q_label, q_progressbar, on_finish_func ):
+
+        self.image_paths = image_paths
+        self.image_paths_len = len(image_paths)
+        self.idxs = [*range(self.image_paths_len)]
+
+        self.filtered_image_paths = self.image_paths.copy()
+
+        self.image_paths_has_ie_polys = { image_path : False for image_path in self.image_paths }
+
+        self.q_label = q_label
+        self.q_progressbar = q_progressbar
+        self.q_progressbar.setRange(0, self.image_paths_len)
+        self.q_progressbar.setValue(0)
+        self.q_progressbar.update()
+        self.on_finish_func = on_finish_func
+        self.done_count = 0
+        super().__init__('LoaderQSubprocessor', LoaderQSubprocessor.Cli, 60)
+
+    def get_data(self, host_dict):
+        if len (self.idxs) > 0:
+            idx = self.idxs.pop(0)
+            image_path = self.image_paths[idx]
+            self.q_label.setText(f'{QStringDB.loading_tip}... {image_path.name}')
+
+            return idx, image_path
+
+        return None
+
+    def on_clients_finalized(self):
+        self.on_finish_func([x for x in self.filtered_image_paths if x is not None], self.image_paths_has_ie_polys)
+
+    def on_data_return (self, host_dict, data):
+        self.idxs.insert(0, data[0])
+
+    def on_result (self, host_dict, data, result):
+        idx, has_dflimg, has_ie_polys = result
+
+        if not has_dflimg:
+            self.filtered_image_paths[idx] = None
+        self.image_paths_has_ie_polys[self.image_paths[idx]] = has_ie_polys
+
+        self.done_count += 1
+        if self.q_progressbar is not None:
+            self.q_progressbar.setValue(self.done_count)
+
+    class Cli(QSubprocessor.Cli):
+        def process_data(self, data):
+            idx, filename = data
+            dflimg = DFLIMG.load(filename)
+            if dflimg is not None and dflimg.has_data():
+                ie_polys = dflimg.get_seg_ie_polys()
+
+                return idx, True, ie_polys.has_polys()
+            return idx, False, False
+
+class MainWindow(QXMainWindow):
+
+    def __init__(self, input_dirpath, cfg_root_path):
+        self.loading_frame = None
+        self.help_frame = None
+
+        super().__init__()
+
+        self.input_dirpath = input_dirpath
+        self.trash_dirpath = input_dirpath.parent / (input_dirpath.name + '_trash')
+        self.cfg_root_path = cfg_root_path
+
+        self.cfg_path = cfg_root_path / 'MainWindow_cfg.dat'
+        self.cfg_dict = pickle.loads(self.cfg_path.read_bytes()) if self.cfg_path.exists() else {}
+
+        self.cached_images = {}
+        self.cached_has_ie_polys = {}
+
+        self.initialize_ui()
+
+        # Loader
+        self.loading_frame = QFrame(self.main_canvas_frame)
+        self.loading_frame.setAutoFillBackground(True)
+        self.loading_frame.setFrameShape(QFrame.StyledPanel)
+        self.loader_label = QLabel()
+        self.loader_progress_bar = QProgressBar()
+
+        intro_image = QLabel()
+        intro_image.setPixmap( QPixmap.fromImage(QImageDB.intro) )
+
+        intro_image_frame_l = QVBoxLayout()
+        intro_image_frame_l.addWidget(intro_image, alignment=Qt.AlignCenter)
+        intro_image_frame = QFrame()
+        intro_image_frame.setSizePolicy (QSizePolicy.Expanding, QSizePolicy.Expanding)
+        intro_image_frame.setLayout(intro_image_frame_l)
+
+        loading_frame_l = QVBoxLayout()
+        loading_frame_l.addWidget (intro_image_frame)
+        loading_frame_l.addWidget (self.loader_label)
+        loading_frame_l.addWidget (self.loader_progress_bar)
+        self.loading_frame.setLayout(loading_frame_l)
+
+        self.loader_subprocessor = LoaderQSubprocessor( image_paths=pathex.get_image_paths(input_dirpath, return_Path_class=True),
+                                                        q_label=self.loader_label,
+                                                        q_progressbar=self.loader_progress_bar,
+                                                        on_finish_func=self.on_loader_finish )
+
+
+    def on_loader_finish(self, image_paths, image_paths_has_ie_polys):
+        self.image_paths_done = []
+        self.image_paths = image_paths
+        self.image_paths_has_ie_polys = image_paths_has_ie_polys
+        self.set_has_ie_polys_count ( len([ 1 for x in self.image_paths_has_ie_polys if self.image_paths_has_ie_polys[x] == True]) )
+        self.loading_frame.hide()
+        self.loading_frame = None
+
+        self.process_next_image(first_initialization=True)
+
+    def closeEvent(self, ev):
+        self.cfg_dict['geometry'] = self.saveGeometry().data()
+        self.cfg_path.write_bytes( pickle.dumps(self.cfg_dict) )
+
+
+    def update_cached_images (self, count=5):
+        d = self.cached_images
+
+        for image_path in self.image_paths_done[:-count]+self.image_paths[count:]:
+            if image_path in d:
+                del d[image_path]
+
+        for image_path in self.image_paths[:count]+self.image_paths_done[-count:]:
+            if image_path not in d:
+                img = cv2_imread(image_path)
+                if img is not None:
+                    d[image_path] = img
+
+    def load_image(self, image_path):
+        try:
+            img = self.cached_images.get(image_path, None)
+            if img is None:
+                img = cv2_imread(image_path)
+                self.cached_images[image_path] = img
+            if img is None:
+                io.log_err(f'Unable to load {image_path}')
+        except:
+            img = None
+
+        return img
+
+    def update_preview_bar(self):
+        count = self.image_bar.get_preview_images_count()
+        d = self.cached_images
+        prev_imgs = [ d.get(image_path, None) for image_path in self.image_paths_done[-1:-count:-1] ]
+        next_imgs = [ d.get(image_path, None) for image_path in self.image_paths[:count] ]
+        self.image_bar.update_images(prev_imgs, next_imgs)
+
+
+    def canvas_initialize(self, image_path, only_has_polys=False):
+        if only_has_polys and not self.image_paths_has_ie_polys[image_path]:
+            return False
+
+        dflimg = DFLIMG.load(image_path)
+        if not dflimg or not dflimg.has_data():
+            return False
+
+        ie_polys = dflimg.get_seg_ie_polys()
+        xseg_mask = dflimg.get_xseg_mask()
+        img = self.load_image(image_path)
+        if img is None:
+            return False
+
+        self.canvas.op.initialize ( img,  ie_polys=ie_polys, xseg_mask=xseg_mask )
+
+        self.filename_label.setText(f"{image_path.name}")
+
+        return True
+
+    def canvas_finalize(self, image_path):
+        self.canvas.op.finalize()
+
+        if image_path.exists():
+            dflimg = DFLIMG.load(image_path)
+            ie_polys = dflimg.get_seg_ie_polys()
+            new_ie_polys = self.canvas.op.get_ie_polys()
+
+            if not new_ie_polys.identical(ie_polys):
+                prev_has_polys = self.image_paths_has_ie_polys[image_path]
+                self.image_paths_has_ie_polys[image_path] = new_ie_polys.has_polys()
+                new_has_polys = self.image_paths_has_ie_polys[image_path]
+
+                if not prev_has_polys and new_has_polys:
+                    self.set_has_ie_polys_count ( self.get_has_ie_polys_count() +1)
+                elif prev_has_polys and not new_has_polys:
+                    self.set_has_ie_polys_count ( self.get_has_ie_polys_count() -1)
+
+                dflimg.set_seg_ie_polys( new_ie_polys )
+                dflimg.save()
+
+        self.filename_label.setText(f"")
+
+    def process_prev_image(self):
+        key_mods = QApplication.keyboardModifiers()
+        step = 5 if key_mods == Qt.ShiftModifier else 1
+        only_has_polys = key_mods == Qt.ControlModifier
+
+        if self.canvas.op.is_initialized():
+            self.canvas_finalize(self.image_paths[0])
+
+        while True:
+            for _ in range(step):
+                if len(self.image_paths_done) != 0:
+                    self.image_paths.insert (0, self.image_paths_done.pop(-1))
+                else:
+                    break
+            if len(self.image_paths) == 0:
+                break
+
+            ret = self.canvas_initialize(self.image_paths[0], len(self.image_paths_done) != 0 and only_has_polys)
+
+            if ret or len(self.image_paths_done) == 0:
+                break
+
+        self.update_cached_images()
+        self.update_preview_bar()
+
+    def process_next_image(self, first_initialization=False):
+        key_mods = QApplication.keyboardModifiers()
+
+        step = 0 if first_initialization else 5 if key_mods == Qt.ShiftModifier else 1
+        only_has_polys = False if first_initialization else key_mods == Qt.ControlModifier
+
+        if self.canvas.op.is_initialized():
+            self.canvas_finalize(self.image_paths[0])
+
+        while True:
+            for _ in range(step):
+                if len(self.image_paths) != 0:
+                    self.image_paths_done.append(self.image_paths.pop(0))
+                else:
+                    break
+            if len(self.image_paths) == 0:
+                break
+            if self.canvas_initialize(self.image_paths[0], only_has_polys):
+                break
+
+        self.update_cached_images()
+        self.update_preview_bar()
+        
+    def trash_current_image(self):
+        self.process_next_image()
+        
+        img_path = self.image_paths_done.pop(-1)
+        img_path = Path(img_path)
+        self.trash_dirpath.mkdir(parents=True, exist_ok=True)
+        img_path.rename( self.trash_dirpath / img_path.name )
+        
+        self.update_cached_images()
+        self.update_preview_bar()
+        
+    def initialize_ui(self):
+
+        self.canvas = QCanvas()
+
+        image_bar = self.image_bar = ImagePreviewSequenceBar(preview_images_count=9, icon_size=QUIConfig.preview_bar_icon_q_size.width())
+        image_bar.setSizePolicy ( QSizePolicy.Fixed, QSizePolicy.Fixed )
+
+
+        btn_prev_image = QXIconButton(QIconDB.left, QStringDB.btn_prev_image_tip, shortcut='A', click_func=self.process_prev_image)
+        btn_prev_image.setIconSize(QUIConfig.preview_bar_icon_q_size)
+
+        btn_next_image = QXIconButton(QIconDB.right, QStringDB.btn_next_image_tip, shortcut='D', click_func=self.process_next_image)
+        btn_next_image.setIconSize(QUIConfig.preview_bar_icon_q_size)
+
+        btn_delete_image = QXIconButton(QIconDB.trashcan, QStringDB.btn_delete_image_tip, shortcut='X', click_func=self.trash_current_image)
+        btn_delete_image.setIconSize(QUIConfig.preview_bar_icon_q_size)
+    
+        pad_image = QWidget()
+        pad_image.setFixedSize(QUIConfig.preview_bar_icon_q_size)
+        
+        preview_image_bar_frame_l = QHBoxLayout()
+        preview_image_bar_frame_l.setContentsMargins(0,0,0,0)
+        preview_image_bar_frame_l.addWidget ( pad_image, alignment=Qt.AlignCenter)
+        preview_image_bar_frame_l.addWidget ( btn_prev_image, alignment=Qt.AlignCenter)
+        preview_image_bar_frame_l.addWidget ( image_bar)
+        preview_image_bar_frame_l.addWidget ( btn_next_image, alignment=Qt.AlignCenter)
+        #preview_image_bar_frame_l.addWidget ( btn_delete_image, alignment=Qt.AlignCenter)
+
+        preview_image_bar_frame = QFrame()
+        preview_image_bar_frame.setSizePolicy ( QSizePolicy.Fixed, QSizePolicy.Fixed )
+        preview_image_bar_frame.setLayout(preview_image_bar_frame_l)
+
+        preview_image_bar_frame2_l = QHBoxLayout()
+        preview_image_bar_frame2_l.setContentsMargins(0,0,0,0)
+        preview_image_bar_frame2_l.addWidget ( btn_delete_image, alignment=Qt.AlignCenter)
+
+        preview_image_bar_frame2 = QFrame()
+        preview_image_bar_frame2.setSizePolicy ( QSizePolicy.Fixed, QSizePolicy.Fixed )
+        preview_image_bar_frame2.setLayout(preview_image_bar_frame2_l)
+        
+        preview_image_bar_l = QHBoxLayout()
+        preview_image_bar_l.addWidget (preview_image_bar_frame, alignment=Qt.AlignCenter)
+        preview_image_bar_l.addWidget (preview_image_bar_frame2)
+        
+        preview_image_bar = QFrame()
+        preview_image_bar.setFrameShape(QFrame.StyledPanel)
+        preview_image_bar.setSizePolicy ( QSizePolicy.Expanding, QSizePolicy.Fixed )
+        preview_image_bar.setLayout(preview_image_bar_l)
+
+        label_font = QFont('Courier New')
+        self.filename_label = QLabel()
+        self.filename_label.setFont(label_font)
+
+        self.has_ie_polys_count_label = QLabel()
+
+        status_frame_l = QHBoxLayout()
+        status_frame_l.setContentsMargins(0,0,0,0)
+        status_frame_l.addWidget ( QLabel(), alignment=Qt.AlignCenter)
+        status_frame_l.addWidget (self.filename_label, alignment=Qt.AlignCenter)
+        status_frame_l.addWidget (self.has_ie_polys_count_label, alignment=Qt.AlignCenter)
+        status_frame = QFrame()
+        status_frame.setLayout(status_frame_l)
+
+        main_canvas_l = QVBoxLayout()
+        main_canvas_l.setContentsMargins(0,0,0,0)
+        main_canvas_l.addWidget (self.canvas)
+        main_canvas_l.addWidget (status_frame)
+        main_canvas_l.addWidget (preview_image_bar)
+
+        self.main_canvas_frame = QFrame()
+        self.main_canvas_frame.setLayout(main_canvas_l)
+
+        self.main_l = QHBoxLayout()
+        self.main_l.setContentsMargins(0,0,0,0)
+        self.main_l.addWidget (self.main_canvas_frame)
+
+        self.setLayout(self.main_l)
+
+        geometry = self.cfg_dict.get('geometry', None)
+        if geometry is not None:
+            self.restoreGeometry(geometry)
+        else:
+            self.move( QPoint(0,0))
+
+    def get_has_ie_polys_count(self):
+        return self.has_ie_polys_count
+
+    def set_has_ie_polys_count(self, c):
+        self.has_ie_polys_count = c
+        self.has_ie_polys_count_label.setText(f"{c} {QStringDB.labeled_tip}")
+
+    def resizeEvent(self, ev):
+        if self.loading_frame is not None:
+            self.loading_frame.resize( ev.size() )
+        if self.help_frame is not None:
+            self.help_frame.resize( ev.size() )
+
+def start(input_dirpath):
+    """
+    returns exit_code
+    """
+    io.log_info("Running XSeg editor.")
+
+    if PackedFaceset.path_contains(input_dirpath):
+        io.log_info (f'\n{input_dirpath} contains packed faceset! Unpack it first.\n')
+        return 1
+
+    root_path = Path(__file__).parent
+    cfg_root_path = Path(tempfile.gettempdir())
+
+    QApplication.setAttribute(Qt.AA_EnableHighDpiScaling, True)
+    QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps, True)
+
+    app = QApplication([])
+    app.setApplicationName("XSegEditor")
+    app.setStyle('Fusion')
+
+    QFontDatabase.addApplicationFont( str(root_path / 'gfx' / 'fonts' / 'NotoSans-Medium.ttf') )
+
+    app.setFont( QFont('NotoSans'))
+
+    QUIConfig.initialize()
+    QStringDB.initialize()
+
+    QIconDB.initialize( root_path / 'gfx' / 'icons' )
+    QCursorDB.initialize( root_path / 'gfx' / 'cursors' )
+    QImageDB.initialize( root_path / 'gfx' / 'images' )
+
+    app.setWindowIcon(QIconDB.app_icon)
+    app.setPalette( QDarkPalette() )
+
+    win = MainWindow( input_dirpath=input_dirpath, cfg_root_path=cfg_root_path)
+
+    win.show()
+    win.raise_()
+
+    app.exec_()
+    return 0

_config.yml

@@ -0,0 +1,9 @@
+theme: jekyll-theme-cayman
+plugins:
+  - jekyll-relative-links
+relative_links:
+  enabled: true
+  collections: true
+  
+include:
+  - README.md

core/cv2ex.py

@@ -0,0 +1,40 @@
+import cv2
+import numpy as np
+from pathlib import Path
+from core.interact import interact as io
+from core import imagelib 
+import traceback
+
+def cv2_imread(filename, flags=cv2.IMREAD_UNCHANGED, loader_func=None, verbose=True):
+    """
+    allows to open non-english characters path
+    """
+    try:
+        if loader_func is not None:
+            bytes = bytearray(loader_func(filename))
+        else:
+            with open(filename, "rb") as stream:
+                bytes = bytearray(stream.read())
+        numpyarray = np.asarray(bytes, dtype=np.uint8)
+        return cv2.imdecode(numpyarray, flags)
+    except:
+        if verbose:
+            io.log_err(f"Exception occured in cv2_imread : {traceback.format_exc()}")
+        return None
+
+def cv2_imwrite(filename, img, *args):
+    ret, buf = cv2.imencode( Path(filename).suffix, img, *args)
+    if ret == True:
+        try:
+            with open(filename, "wb") as stream:
+                stream.write( buf )
+        except:
+            pass
+
+def cv2_resize(x, *args, **kwargs):
+    h,w,c = x.shape
+    x = cv2.resize(x, *args, **kwargs)
+    
+    x = imagelib.normalize_channels(x, c)
+    return x
+    

core/imagelib/SegIEPolys.py

@@ -0,0 +1,158 @@
+import numpy as np
+import cv2
+from enum import IntEnum
+
+
+class SegIEPolyType(IntEnum):
+    EXCLUDE = 0
+    INCLUDE = 1
+    
+
+
+class SegIEPoly():
+    def __init__(self, type=None, pts=None, **kwargs):
+        self.type = type
+        
+        if pts is None:
+            pts = np.empty( (0,2), dtype=np.float32 )
+        else:
+            pts = np.float32(pts)
+        self.pts = pts
+        self.n_max = self.n = len(pts)
+
+    def dump(self):
+        return {'type': int(self.type),
+                'pts' : self.get_pts(),
+               }
+    
+    def identical(self, b):
+        if self.n != b.n:
+            return False            
+        return (self.pts[0:self.n] == b.pts[0:b.n]).all()        
+        
+    def get_type(self):
+        return self.type
+
+    def add_pt(self, x, y):
+        self.pts = np.append(self.pts[0:self.n], [ ( float(x), float(y) ) ], axis=0).astype(np.float32)
+        self.n_max = self.n = self.n + 1
+
+    def undo(self):
+        self.n = max(0, self.n-1)
+        return self.n
+
+    def redo(self):
+        self.n = min(len(self.pts), self.n+1)
+        return self.n
+
+    def redo_clip(self):
+        self.pts = self.pts[0:self.n]
+        self.n_max = self.n
+
+    def insert_pt(self, n, pt):
+        if n < 0 or n > self.n:
+            raise ValueError("insert_pt out of range")
+        self.pts = np.concatenate( (self.pts[0:n], pt[None,...].astype(np.float32), self.pts[n:]), axis=0)
+        self.n_max = self.n = self.n+1
+        
+    def remove_pt(self, n):
+        if n < 0 or n >= self.n:
+            raise ValueError("remove_pt out of range")
+        self.pts = np.concatenate( (self.pts[0:n], self.pts[n+1:]), axis=0)
+        self.n_max = self.n = self.n-1
+        
+    def get_last_point(self):
+        return self.pts[self.n-1].copy()
+
+    def get_pts(self):
+        return self.pts[0:self.n].copy()
+        
+    def get_pts_count(self):
+        return self.n
+
+    def set_point(self, id, pt):
+        self.pts[id] = pt
+        
+    def set_points(self, pts):
+        self.pts = np.array(pts)
+        self.n_max = self.n = len(pts)
+        
+    def mult_points(self, val):
+        self.pts *= val       
+    
+        
+
+class SegIEPolys():
+    def __init__(self):
+        self.polys = []
+
+    def identical(self, b):
+        polys_len = len(self.polys)
+        o_polys_len = len(b.polys)
+        if polys_len != o_polys_len:
+            return False
+        
+        return all ([ a_poly.identical(b_poly) for a_poly, b_poly in zip(self.polys, b.polys) ])
+        
+    def add_poly(self, ie_poly_type):       
+        poly = SegIEPoly(ie_poly_type)
+        self.polys.append (poly)
+        return poly
+
+    def remove_poly(self, poly):
+        if poly in self.polys:
+            self.polys.remove(poly)
+
+    def has_polys(self):
+        return len(self.polys) != 0
+        
+    def get_poly(self, id):
+        return self.polys[id]
+
+    def get_polys(self):
+        return self.polys
+        
+    def get_pts_count(self):
+        return sum([poly.get_pts_count() for poly in self.polys])
+        
+    def sort(self):
+        poly_by_type = { SegIEPolyType.EXCLUDE : [], SegIEPolyType.INCLUDE : [] }
+
+        for poly in self.polys:
+            poly_by_type[poly.type].append(poly)
+            
+        self.polys = poly_by_type[SegIEPolyType.INCLUDE] + poly_by_type[SegIEPolyType.EXCLUDE]
+
+    def __iter__(self):
+        for poly in self.polys:
+            yield poly
+
+    def overlay_mask(self, mask):
+        h,w,c = mask.shape
+        white = (1,)*c
+        black = (0,)*c
+        for poly in self.polys:
+            pts = poly.get_pts().astype(np.int32)
+            if len(pts) != 0:
+                cv2.fillPoly(mask, [pts], white if poly.type == SegIEPolyType.INCLUDE else black )
+
+    def dump(self):
+        return {'polys' : [ poly.dump() for poly in self.polys ] }
+    
+    def mult_points(self, val):
+        for poly in self.polys:
+            poly.mult_points(val)
+        
+    @staticmethod
+    def load(data=None):
+        ie_polys = SegIEPolys()
+        if data is not None:
+            if isinstance(data, list):
+                # Backward comp
+                ie_polys.polys = [ SegIEPoly(type=type, pts=pts) for (type, pts) in data ]
+            elif isinstance(data, dict):                
+                ie_polys.polys = [ SegIEPoly(**poly_cfg) for poly_cfg in data['polys'] ]
+                
+        ie_polys.sort()   
+                
+        return ie_polys

core/imagelib/__init__.py

@@ -0,0 +1,32 @@
+from .estimate_sharpness import estimate_sharpness
+
+from .equalize_and_stack_square import equalize_and_stack_square
+
+from .text import get_text_image, get_draw_text_lines
+
+from .draw import draw_polygon, draw_rect
+
+from .morph import morph_by_points
+
+from .warp import gen_warp_params, warp_by_params
+
+from .reduce_colors import reduce_colors
+
+from .color_transfer import color_transfer, color_transfer_mix, color_transfer_sot, color_transfer_mkl, color_transfer_idt, color_hist_match, reinhard_color_transfer, linear_color_transfer
+
+from .common import random_crop, normalize_channels, cut_odd_image, overlay_alpha_image
+
+from .SegIEPolys import *
+
+from .blursharpen import LinearMotionBlur, blursharpen
+
+from .filters import apply_random_rgb_levels, \
+                     apply_random_overlay_triangle, \
+                     apply_random_hsv_shift, \
+                     apply_random_sharpen, \
+                     apply_random_motion_blur, \
+                     apply_random_gaussian_blur, \
+                     apply_random_nearest_resize, \
+                     apply_random_bilinear_resize, \
+                     apply_random_jpeg_compress, \
+                     apply_random_relight

core/imagelib/blursharpen.py

@@ -0,0 +1,38 @@
+import cv2
+import numpy as np
+
+def LinearMotionBlur(image, size, angle):
+    k = np.zeros((size, size), dtype=np.float32)
+    k[ (size-1)// 2 , :] = np.ones(size, dtype=np.float32)
+    k = cv2.warpAffine(k, cv2.getRotationMatrix2D( (size / 2 -0.5 , size / 2 -0.5 ) , angle, 1.0), (size, size) )
+    k = k * ( 1.0 / np.sum(k) )
+    return cv2.filter2D(image, -1, k)
+    
+def blursharpen (img, sharpen_mode=0, kernel_size=3, amount=100):
+    if kernel_size % 2 == 0:
+        kernel_size += 1
+    if amount > 0:
+        if sharpen_mode == 1: #box
+            kernel = np.zeros( (kernel_size, kernel_size), dtype=np.float32)
+            kernel[ kernel_size//2, kernel_size//2] = 1.0
+            box_filter = np.ones( (kernel_size, kernel_size), dtype=np.float32) / (kernel_size**2)
+            kernel = kernel + (kernel - box_filter) * amount
+            return cv2.filter2D(img, -1, kernel)
+        elif sharpen_mode == 2: #gaussian
+            blur = cv2.GaussianBlur(img, (kernel_size, kernel_size) , 0)
+            img = cv2.addWeighted(img, 1.0 + (0.5 * amount), blur, -(0.5 * amount), 0)
+            return img
+    elif amount < 0:
+        n = -amount
+        while n > 0:
+
+            img_blur = cv2.medianBlur(img, 5)
+            if int(n / 10) != 0:
+                img = img_blur
+            else:
+                pass_power = (n % 10) / 10.0
+                img = img*(1.0-pass_power)+img_blur*pass_power
+            n = max(n-10,0)
+
+        return img
+    return img

core/imagelib/color_transfer.py

@@ -0,0 +1,336 @@
+import cv2
+import numexpr as ne
+import numpy as np
+import scipy as sp
+from numpy import linalg as npla
+
+
+def color_transfer_sot(src,trg, steps=10, batch_size=5, reg_sigmaXY=16.0, reg_sigmaV=5.0):
+    """
+    Color Transform via Sliced Optimal Transfer
+    ported by @iperov from https://github.com/dcoeurjo/OTColorTransfer
+
+    src         - any float range any channel image
+    dst         - any float range any channel image, same shape as src
+    steps       - number of solver steps
+    batch_size  - solver batch size
+    reg_sigmaXY - apply regularization and sigmaXY of filter, otherwise set to 0.0
+    reg_sigmaV  - sigmaV of filter
+
+    return value - clip it manually
+    """
+    if not np.issubdtype(src.dtype, np.floating):
+        raise ValueError("src value must be float")
+    if not np.issubdtype(trg.dtype, np.floating):
+        raise ValueError("trg value must be float")
+
+    if len(src.shape) != 3:
+        raise ValueError("src shape must have rank 3 (h,w,c)")
+
+    if src.shape != trg.shape:
+        raise ValueError("src and trg shapes must be equal")
+
+    src_dtype = src.dtype
+    h,w,c = src.shape
+    new_src = src.copy()
+
+    advect = np.empty ( (h*w,c), dtype=src_dtype )
+    for step in range (steps):
+        advect.fill(0)
+        for batch in range (batch_size):
+            dir = np.random.normal(size=c).astype(src_dtype)
+            dir /= npla.norm(dir)
+
+            projsource = np.sum( new_src*dir, axis=-1).reshape ((h*w))
+            projtarget = np.sum( trg*dir, axis=-1).reshape ((h*w))
+
+            idSource = np.argsort (projsource)
+            idTarget = np.argsort (projtarget)
+
+            a = projtarget[idTarget]-projsource[idSource]
+            for i_c in range(c):
+                advect[idSource,i_c] += a * dir[i_c]
+        new_src += advect.reshape( (h,w,c) ) / batch_size
+
+    if reg_sigmaXY != 0.0:
+        src_diff = new_src-src
+        src_diff_filt = cv2.bilateralFilter (src_diff, 0, reg_sigmaV, reg_sigmaXY )
+        if len(src_diff_filt.shape) == 2:
+            src_diff_filt = src_diff_filt[...,None]
+        new_src = src + src_diff_filt
+    return new_src
+
+def color_transfer_mkl(x0, x1):
+    eps = np.finfo(float).eps
+
+    h,w,c = x0.shape
+    h1,w1,c1 = x1.shape
+
+    x0 = x0.reshape ( (h*w,c) )
+    x1 = x1.reshape ( (h1*w1,c1) )
+
+    a = np.cov(x0.T)
+    b = np.cov(x1.T)
+
+    Da2, Ua = np.linalg.eig(a)
+    Da = np.diag(np.sqrt(Da2.clip(eps, None)))
+
+    C = np.dot(np.dot(np.dot(np.dot(Da, Ua.T), b), Ua), Da)
+
+    Dc2, Uc = np.linalg.eig(C)
+    Dc = np.diag(np.sqrt(Dc2.clip(eps, None)))
+
+    Da_inv = np.diag(1./(np.diag(Da)))
+
+    t = np.dot(np.dot(np.dot(np.dot(np.dot(np.dot(Ua, Da_inv), Uc), Dc), Uc.T), Da_inv), Ua.T)
+
+    mx0 = np.mean(x0, axis=0)
+    mx1 = np.mean(x1, axis=0)
+
+    result = np.dot(x0-mx0, t) + mx1
+    return np.clip ( result.reshape ( (h,w,c) ).astype(x0.dtype), 0, 1)
+
+def color_transfer_idt(i0, i1, bins=256, n_rot=20):
+    import scipy.stats
+    
+    relaxation = 1 / n_rot
+    h,w,c = i0.shape
+    h1,w1,c1 = i1.shape
+
+    i0 = i0.reshape ( (h*w,c) )
+    i1 = i1.reshape ( (h1*w1,c1) )
+
+    n_dims = c
+
+    d0 = i0.T
+    d1 = i1.T
+
+    for i in range(n_rot):
+
+        r = sp.stats.special_ortho_group.rvs(n_dims).astype(np.float32)
+
+        d0r = np.dot(r, d0)
+        d1r = np.dot(r, d1)
+        d_r = np.empty_like(d0)
+
+        for j in range(n_dims):
+
+            lo = min(d0r[j].min(), d1r[j].min())
+            hi = max(d0r[j].max(), d1r[j].max())
+
+            p0r, edges = np.histogram(d0r[j], bins=bins, range=[lo, hi])
+            p1r, _     = np.histogram(d1r[j], bins=bins, range=[lo, hi])
+
+            cp0r = p0r.cumsum().astype(np.float32)
+            cp0r /= cp0r[-1]
+
+            cp1r = p1r.cumsum().astype(np.float32)
+            cp1r /= cp1r[-1]
+
+            f = np.interp(cp0r, cp1r, edges[1:])
+
+            d_r[j] = np.interp(d0r[j], edges[1:], f, left=0, right=bins)
+
+        d0 = relaxation * np.linalg.solve(r, (d_r - d0r)) + d0
+
+    return np.clip ( d0.T.reshape ( (h,w,c) ).astype(i0.dtype) , 0, 1)
+
+def reinhard_color_transfer(target : np.ndarray, source : np.ndarray, target_mask : np.ndarray = None, source_mask : np.ndarray = None, mask_cutoff=0.5) -> np.ndarray:
+    """
+    Transfer color using rct method.
+
+        target      np.ndarray H W 3C   (BGR)   np.float32
+        source      np.ndarray H W 3C   (BGR)   np.float32
+
+        target_mask(None)   np.ndarray H W 1C  np.float32
+        source_mask(None)   np.ndarray H W 1C  np.float32
+        
+        mask_cutoff(0.5)    float
+
+    masks are used to limit the space where color statistics will be computed to adjust the target
+
+    reference: Color Transfer between Images https://www.cs.tau.ac.il/~turkel/imagepapers/ColorTransfer.pdf
+    """
+    source = cv2.cvtColor(source, cv2.COLOR_BGR2LAB)
+    target = cv2.cvtColor(target, cv2.COLOR_BGR2LAB)
+
+    source_input = source
+    if source_mask is not None:
+        source_input = source_input.copy()
+        source_input[source_mask[...,0] < mask_cutoff] = [0,0,0]
+    
+    target_input = target
+    if target_mask is not None:
+        target_input = target_input.copy()
+        target_input[target_mask[...,0] < mask_cutoff] = [0,0,0]
+
+    target_l_mean, target_l_std, target_a_mean, target_a_std, target_b_mean, target_b_std, \
+        = target_input[...,0].mean(), target_input[...,0].std(), target_input[...,1].mean(), target_input[...,1].std(), target_input[...,2].mean(), target_input[...,2].std()
+    
+    source_l_mean, source_l_std, source_a_mean, source_a_std, source_b_mean, source_b_std, \
+        = source_input[...,0].mean(), source_input[...,0].std(), source_input[...,1].mean(), source_input[...,1].std(), source_input[...,2].mean(), source_input[...,2].std()
+    
+    # not as in the paper: scale by the standard deviations using reciprocal of paper proposed factor
+    target_l = target[...,0]
+    target_l = ne.evaluate('(target_l - target_l_mean) * source_l_std / target_l_std + source_l_mean')
+
+    target_a = target[...,1]
+    target_a = ne.evaluate('(target_a - target_a_mean) * source_a_std / target_a_std + source_a_mean')
+    
+    target_b = target[...,2]
+    target_b = ne.evaluate('(target_b - target_b_mean) * source_b_std / target_b_std + source_b_mean')
+
+    np.clip(target_l,    0, 100, out=target_l)
+    np.clip(target_a, -127, 127, out=target_a)
+    np.clip(target_b, -127, 127, out=target_b)
+
+    return cv2.cvtColor(np.stack([target_l,target_a,target_b], -1), cv2.COLOR_LAB2BGR)
+
+
+def linear_color_transfer(target_img, source_img, mode='pca', eps=1e-5):
+    '''
+    Matches the colour distribution of the target image to that of the source image
+    using a linear transform.
+    Images are expected to be of form (w,h,c) and float in [0,1].
+    Modes are chol, pca or sym for different choices of basis.
+    '''
+    mu_t = target_img.mean(0).mean(0)
+    t = target_img - mu_t
+    t = t.transpose(2,0,1).reshape( t.shape[-1],-1)
+    Ct = t.dot(t.T) / t.shape[1] + eps * np.eye(t.shape[0])
+    mu_s = source_img.mean(0).mean(0)
+    s = source_img - mu_s
+    s = s.transpose(2,0,1).reshape( s.shape[-1],-1)
+    Cs = s.dot(s.T) / s.shape[1] + eps * np.eye(s.shape[0])
+    if mode == 'chol':
+        chol_t = np.linalg.cholesky(Ct)
+        chol_s = np.linalg.cholesky(Cs)
+        ts = chol_s.dot(np.linalg.inv(chol_t)).dot(t)
+    if mode == 'pca':
+        eva_t, eve_t = np.linalg.eigh(Ct)
+        Qt = eve_t.dot(np.sqrt(np.diag(eva_t))).dot(eve_t.T)
+        eva_s, eve_s = np.linalg.eigh(Cs)
+        Qs = eve_s.dot(np.sqrt(np.diag(eva_s))).dot(eve_s.T)
+        ts = Qs.dot(np.linalg.inv(Qt)).dot(t)
+    if mode == 'sym':
+        eva_t, eve_t = np.linalg.eigh(Ct)
+        Qt = eve_t.dot(np.sqrt(np.diag(eva_t))).dot(eve_t.T)
+        Qt_Cs_Qt = Qt.dot(Cs).dot(Qt)
+        eva_QtCsQt, eve_QtCsQt = np.linalg.eigh(Qt_Cs_Qt)
+        QtCsQt = eve_QtCsQt.dot(np.sqrt(np.diag(eva_QtCsQt))).dot(eve_QtCsQt.T)
+        ts = np.linalg.inv(Qt).dot(QtCsQt).dot(np.linalg.inv(Qt)).dot(t)
+    matched_img = ts.reshape(*target_img.transpose(2,0,1).shape).transpose(1,2,0)
+    matched_img += mu_s
+    matched_img[matched_img>1] = 1
+    matched_img[matched_img<0] = 0
+    return np.clip(matched_img.astype(source_img.dtype), 0, 1)
+
+def lab_image_stats(image):
+    # compute the mean and standard deviation of each channel
+    (l, a, b) = cv2.split(image)
+    (lMean, lStd) = (l.mean(), l.std())
+    (aMean, aStd) = (a.mean(), a.std())
+    (bMean, bStd) = (b.mean(), b.std())
+
+    # return the color statistics
+    return (lMean, lStd, aMean, aStd, bMean, bStd)
+
+def _scale_array(arr, clip=True):
+    if clip:
+        return np.clip(arr, 0, 255)
+
+    mn = arr.min()
+    mx = arr.max()
+    scale_range = (max([mn, 0]), min([mx, 255]))
+
+    if mn < scale_range[0] or mx > scale_range[1]:
+        return (scale_range[1] - scale_range[0]) * (arr - mn) / (mx - mn) + scale_range[0]
+
+    return arr
+
+def channel_hist_match(source, template, hist_match_threshold=255, mask=None):
+    # Code borrowed from:
+    # https://stackoverflow.com/questions/32655686/histogram-matching-of-two-images-in-python-2-x
+    masked_source = source
+    masked_template = template
+
+    if mask is not None:
+        masked_source = source * mask
+        masked_template = template * mask
+
+    oldshape = source.shape
+    source = source.ravel()
+    template = template.ravel()
+    masked_source = masked_source.ravel()
+    masked_template = masked_template.ravel()
+    s_values, bin_idx, s_counts = np.unique(source, return_inverse=True,
+                                            return_counts=True)
+    t_values, t_counts = np.unique(template, return_counts=True)
+
+    s_quantiles = np.cumsum(s_counts).astype(np.float64)
+    s_quantiles = hist_match_threshold * s_quantiles / s_quantiles[-1]
+    t_quantiles = np.cumsum(t_counts).astype(np.float64)
+    t_quantiles = 255 * t_quantiles / t_quantiles[-1]
+    interp_t_values = np.interp(s_quantiles, t_quantiles, t_values)
+
+    return interp_t_values[bin_idx].reshape(oldshape)
+
+def color_hist_match(src_im, tar_im, hist_match_threshold=255):
+    h,w,c = src_im.shape
+    matched_R = channel_hist_match(src_im[:,:,0], tar_im[:,:,0], hist_match_threshold, None)
+    matched_G = channel_hist_match(src_im[:,:,1], tar_im[:,:,1], hist_match_threshold, None)
+    matched_B = channel_hist_match(src_im[:,:,2], tar_im[:,:,2], hist_match_threshold, None)
+
+    to_stack = (matched_R, matched_G, matched_B)
+    for i in range(3, c):
+        to_stack += ( src_im[:,:,i],)
+
+
+    matched = np.stack(to_stack, axis=-1).astype(src_im.dtype)
+    return matched
+
+def color_transfer_mix(img_src,img_trg):
+    img_src = np.clip(img_src*255.0, 0, 255).astype(np.uint8)
+    img_trg = np.clip(img_trg*255.0, 0, 255).astype(np.uint8)
+
+    img_src_lab = cv2.cvtColor(img_src, cv2.COLOR_BGR2LAB)
+    img_trg_lab = cv2.cvtColor(img_trg, cv2.COLOR_BGR2LAB)
+
+    rct_light = np.clip ( linear_color_transfer(img_src_lab[...,0:1].astype(np.float32)/255.0,
+                                                img_trg_lab[...,0:1].astype(np.float32)/255.0 )[...,0]*255.0,
+                          0, 255).astype(np.uint8)
+
+    img_src_lab[...,0] = (np.ones_like (rct_light)*100).astype(np.uint8)
+    img_src_lab = cv2.cvtColor(img_src_lab, cv2.COLOR_LAB2BGR)
+
+    img_trg_lab[...,0] = (np.ones_like (rct_light)*100).astype(np.uint8)
+    img_trg_lab = cv2.cvtColor(img_trg_lab, cv2.COLOR_LAB2BGR)
+
+    img_rct = color_transfer_sot( img_src_lab.astype(np.float32), img_trg_lab.astype(np.float32) )
+    img_rct = np.clip(img_rct, 0, 255).astype(np.uint8)
+
+    img_rct = cv2.cvtColor(img_rct, cv2.COLOR_BGR2LAB)
+    img_rct[...,0] = rct_light
+    img_rct = cv2.cvtColor(img_rct, cv2.COLOR_LAB2BGR)
+
+
+    return (img_rct / 255.0).astype(np.float32)
+
+def color_transfer(ct_mode, img_src, img_trg):
+    """
+    color transfer for [0,1] float32 inputs
+    """
+    if ct_mode == 'lct':
+        out = linear_color_transfer (img_src, img_trg)
+    elif ct_mode == 'rct':
+        out = reinhard_color_transfer(img_src, img_trg)
+    elif ct_mode == 'mkl':
+        out = color_transfer_mkl (img_src, img_trg)
+    elif ct_mode == 'idt':
+        out = color_transfer_idt (img_src, img_trg)
+    elif ct_mode == 'sot':
+        out = color_transfer_sot (img_src, img_trg)
+        out = np.clip( out, 0.0, 1.0)
+    else:
+        raise ValueError(f"unknown ct_mode {ct_mode}")
+    return out

core/imagelib/common.py

@@ -0,0 +1,58 @@
+import numpy as np
+
+def random_crop(img, w, h):
+    height, width = img.shape[:2]
+    
+    h_rnd = height - h
+    w_rnd = width - w
+    
+    y = np.random.randint(0, h_rnd) if h_rnd > 0 else 0
+    x = np.random.randint(0, w_rnd) if w_rnd > 0 else 0
+    
+    return img[y:y+height, x:x+width]
+                        
+def normalize_channels(img, target_channels):
+    img_shape_len = len(img.shape)
+    if img_shape_len == 2:
+        h, w = img.shape
+        c = 0
+    elif img_shape_len == 3:
+        h, w, c = img.shape
+    else:
+        raise ValueError("normalize: incorrect image dimensions.")
+
+    if c == 0 and target_channels > 0:
+        img = img[...,np.newaxis]
+        c = 1
+
+    if c == 1 and target_channels > 1:
+        img = np.repeat (img, target_channels, -1)
+        c = target_channels
+
+    if c > target_channels:
+        img = img[...,0:target_channels]
+        c = target_channels
+
+    return img
+
+def cut_odd_image(img):
+    h, w, c = img.shape
+    wm, hm = w % 2, h % 2
+    if wm + hm != 0:
+        img = img[0:h-hm,0:w-wm,:]
+    return img
+
+def overlay_alpha_image(img_target, img_source, xy_offset=(0,0) ):
+    (h,w,c) = img_source.shape
+    if c != 4:
+        raise ValueError("overlay_alpha_image, img_source must have 4 channels")
+
+    x1, x2 = xy_offset[0], xy_offset[0] + w
+    y1, y2 = xy_offset[1], xy_offset[1] + h
+
+    alpha_s = img_source[:, :, 3] / 255.0
+    alpha_l = 1.0 - alpha_s
+
+    for c in range(0, 3):
+        img_target[y1:y2, x1:x2, c] = (alpha_s * img_source[:, :, c] +
+                                        alpha_l * img_target[y1:y2, x1:x2, c])