Upload 1420 files

.gitattributes

@@ -57,3 +57,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+extensions/sd-webui-infinite-image-browsing/vue/src-tauri/icons/icon.icns filter=lfs diff=lfs merge=lfs -text
+modules/Roboto-Regular.ttf filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,44 @@
+__pycache__
+.idea
+.venv
+.vscode
+.vs
+
+**.ckpt
+**.bin
+**.sft
+**.safetensors
+**.pth
+**.pt
+**.sh
+
+/cache
+/extensions
+/models/**/*
+/output
+/outputs
+/repositories
+/venv
+/log
+/tmp
+
+/cache.json
+/config.json
+/ui-config.json
+/styles.csv
+/styles.csv.bak
+/params.txt
+/webui-user.bat
+/webui-user.sh
+/user.css
+notification.mp3
+
+/config_states
+/node_modules
+/package-lock.json
+
+**.exp
+**.lib
+**.obj
+
+*.*.*

LICENSE

@@ -0,0 +1,623 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+                    Copyright (c) 2023 AUTOMATIC1111
+                    Copyright (c) 2024 lllyasviel
+                    Copyright (c) 2025 Haoming02
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are 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.
+
+  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.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  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 Affero 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. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  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 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 work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero 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 Affero 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 Affero 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 Affero 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

README.md

@@ -0,0 +1,424 @@
+<h1 align="center">Stable Diffusion WebUI Forge - Classic</h1>
+
+<p align="center"><img src="html\ui.webp" width=512 alt="UI"></p>
+
+<blockquote><i>
+<b>Stable Diffusion WebUI Forge</b> is a platform on top of the original <a href="https://github.com/AUTOMATIC1111/stable-diffusion-webui">Stable Diffusion WebUI</a> by <ins>AUTOMATIC1111</ins>, to make development easier, optimize resource management, speed up inference, and study experimental features.<br>
+The name "Forge" is inspired by "Minecraft Forge". This project aims to become the Forge of Stable Diffusion WebUI.<br>
+<p align="right">- <b>lllyasviel</b><br>
+<sup>(paraphrased)</sup></p>
+</i></blockquote>
+
+<br>
+
+"**Classic**" mainly serves as an archive for the "`previous`" version of Forge, which was built on [Gradio](https://github.com/gradio-app/gradio) `3.41.2` before the major changes *(see the original [announcement](https://github.com/lllyasviel/stable-diffusion-webui-forge/discussions/801))* were introduced. Additionally, this fork is focused exclusively on **SD1** and **SDXL** checkpoints, having various optimizations implemented, with the main goal of being the lightest WebUI without any bloatwares.
+
+> [!Tip]
+> [How to Install](#installation)
+
+<br>
+
+## Features [Apr. 30]
+> Most base features of the original [Automatic1111 Webui](https://github.com/AUTOMATIC1111/stable-diffusion-webui) should still function
+
+#### New Features
+
+- [X] Support `v-pred` **SDXL** checkpoints *(**eg.** [NoobAI](https://civitai.com/models/833294?modelVersionId=1190596))*
+- [X] Support [uv](https://github.com/astral-sh/uv) package manager
+    - requires **uv**
+    - drastically speed up installation
+    - see [Commandline](#by-classic)
+- [X] Support [SageAttention](https://github.com/thu-ml/SageAttention)
+    - requires **manually** installing the [triton](https://github.com/triton-lang/triton) package
+        - [how to install](#install-triton)
+    - requires RTX **30** +
+    - ~10% speed up
+    - see [Commandline](#by-classic)
+- [X] Support [FlashAttention](https://arxiv.org/abs/2205.14135)
+    - requires **manually** installing the [flash-attn](https://github.com/Dao-AILab/flash-attention) package
+        - [how to install](#install-flash-attn)
+    - ~10% speed up
+- [X] Support fast `fp16_accumulation`
+    - requires PyTorch **2.7.0** +
+    - ~25% speed up
+    - see [Commandline](#by-classic)
+- [X] Support fast `cublas` operation *(`CublasLinear`)*
+    - requires **manually** installing the [cublas_ops](https://github.com/aredden/torch-cublas-hgemm) package
+        - [how to install](#install-cublas)
+    - ~25% speed up
+    - enable in **Settings**
+- [X] Support fast `fp8` operation *(`torch._scaled_mm`)*
+    - requires RTX **40** +
+    - ~10% speed up; reduce quality
+    - enable in **Settings**
+
+> [!Note]
+> - The `fp16_accumulation` and `cublas` operation achieve the same speed up; if you already install/update to `torch==2.7.0`, you do not need to go for `cublas_ops`
+> - The `fp16_accumulation` and `cublas` operation require `fp16` precision, thus is not compatible with the `fp8` operation
+
+- [X] Implement RescaleCFG
+    - reduce burnt colors; mainly for `v-pred` checkpoints
+- [X] Implement MaHiRo
+    - alternative CFG calculation
+    - [graph](https://www.desmos.com/calculator/wcztf0ktiq)
+- [X] Implement `diskcache`
+    - *(backported from Automatic1111 Webui upstream)*
+- [X] Implement `skip_early_cond`
+    - *(backported from Automatic1111 Webui upstream)*
+- [X] Update `spandrel`
+    - support most modern Upscaler architecture
+- [X] Add `pillow-heif` package
+    - support `.avif` and `.heif` formats
+- [X] Automatic row split for `X/Y/Z Plot`
+- [X] Add an option to disable **Refiner**
+- [X] Add an option to disable ExtraNetworks **Tree View**
+- [X] Support [Union](https://huggingface.co/xinsir/controlnet-union-sdxl-1.0) / [ProMax](https://huggingface.co/brad-twinkl/controlnet-union-sdxl-1.0-promax) ControlNet
+    - I just made them always show up in the dropdown
+
+#### Removed Features
+
+- [X] SD2
+- [X] Alt-Diffusion
+- [X] Instruct-Pix2Pix
+- [X] Hypernetworks
+- [X] SVD
+- [X] Z123
+- [X] CLIP Interrogator
+- [X] Deepbooru Interrogator
+- [X] Textual Inversion Training
+- [X] Checkpoint Merging
+- [X] LDSR
+- [X] Most **built-in** Extensions
+- [X] Some **built-in** Scripts
+- [X] The `test` scripts
+- [X] `Photopea` and `openpose_editor` *(ControlNet)*
+- [X] Unix `.sh` launch scripts
+    - You can still use this WebUI by copying a launch script from another working WebUI; I just don't want to maintain them...
+
+#### Optimizations
+
+- [X] **[Freedom]** Natively integrate the `SD1` and `SDXL` logics
+    - no longer `git` `clone` any repository on fresh install
+    - no more random hacks and monkey patches
+- [X] Fix memory leak when switching checkpoints
+- [X] Clean up the `ldm_patched` *(**ie.** `comfy`)* folder
+- [X] Remove unused `cmd_args`
+- [X] Remove unused `shared_options`
+- [X] Remove unused `args_parser`
+- [X] Remove legacy codes
+- [X] Remove duplicated upscaler codes
+    - put every upscaler inside the `ESRGAN` folder
+- [X] Improve color correction
+- [X] Improve code logics
+- [X] Improve hash caching
+- [X] Improve error logs
+    - no longer prints `TypeError: 'NoneType' object is not iterable`
+- [X] Improve setting descriptions
+- [X] Check for Extension updates in parallel
+- [X] Moved `embeddings` folder into `models` folder
+- [X] ControlNet Rewrite
+    - change Units to `gr.Tab`
+    - remove multi-inputs, as they are "[misleading](https://github.com/lllyasviel/stable-diffusion-webui-forge/discussions/932)"
+    - change `visible` toggle to `interactive` toggle; now the UI will no longer jump around
+    - improved `Presets` application
+- [X] Run `text encoder` on CPU by default
+- [X] Fix `pydantic` Errors
+- [X] Fix `Soft Inpainting`
+- [X] Lint & Format most of the Python and JavaScript codes
+- [X] Update to Pillow 11
+    - faster image processing
+- [X] Update `protobuf`
+    - faster `insightface` loading
+- [X] Update to latest PyTorch
+    - `torch==2.7.0+cu128`
+    - `xformers==0.0.30`
+- [X] No longer install `open-clip` twice
+- [X] Update certain packages to newer versions
+- [X] Update recommended Python to `3.11.9`
+- [X] many more... :tm:
+
+<br>
+
+## Commandline
+> These flags can be added after the `set COMMANDLINE_ARGS=` line in the `webui-user.bat` *(separate each flag with space)*
+
+#### A1111 built-in
+
+- `--no-download-sd-model`: Do not download a default checkpoint
+    - can be removed after you download some checkpoints of your choice
+- `--xformers`: Install the `xformers` package to speed up generation
+    - Currently, `torch==2.7.0` does **not** support `xformers` yet
+- `--port`: Specify a server port to use
+    - defaults to `7860`
+- `--api`: Enable [API](https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/API) access
+
+<br>
+
+- Once you have successfully launched the WebUI, you can add the following flags to bypass some validation steps in order to improve the Startup time
+    - `--skip-prepare-environment`
+    - `--skip-install`
+    - `--skip-python-version-check`
+    - `--skip-torch-cuda-test`
+    - `--skip-version-check`
+
+> [!Important]
+> Remove them if you are installing an Extension, as those also block Extension from installing requirements
+
+#### by. Forge
+
+- For RTX **30** and above, you can add the following flags to slightly increase the performance; but in rare occurrences, they may cause `OutOfMemory` errors or even crash the WebUI; and in certain configurations, they may even lower the speed instead
+    - `--cuda-malloc`
+    - `--cuda-stream`
+    - `--pin-shared-memory`
+
+#### by. Classic
+
+- `--uv`: Replace the `python -m pip` calls with `uv pip` to massively speed up package installation
+    - requires **uv** to be installed first *(see [Installation](#installation))*
+- `--uv-symlink`: Same as above; but additionally pass `--link-mode symlink` to the commands
+    - significantly reduces installation size (`~7 GB` to `~100 MB`)
+
+> [!Important]
+> Using `symlink` means it will directly access the packages from the cache folders; refrain from clearing the cache when setting this option
+
+- `--fast-fp16`: Enable the `allow_fp16_accumulation` option
+    - requires PyTorch **2.7.0** +
+- `--sage`: Install the `sageattention` package to speed up generation
+    - requires **triton**
+    - requires RTX **30** +
+    - only affects **SDXL**
+
+> [!Tip]
+> `--xformers` is still recommended even if you already have `--sage`, as `sageattention` does not speed up **VAE** while `xformers` does
+
+- `--model-ref`: Points to a central `models` folder that contains all your models
+    - said folder should contain subfolders like `Stable-diffusion`, `Lora`, `VAE`, `ESRGAN`, etc.
+
+> [!Important]
+> This simply **replaces** the `models` folder, rather than adding on top of it
+
+<br>
+
+## Installation
+
+0. Install **[git](https://git-scm.com/downloads)**
+1. Clone the Repo
+    ```bash
+    git clone https://github.com/Haoming02/sd-webui-forge-classic
+    ```
+
+2. Setup Python
+
+<details>
+<summary>Recommended Method</summary>
+
+- Install **[uv](https://github.com/astral-sh/uv)**
+- Set up **venv**
+    ```bash
+    cd sd-webui-forge-classic
+    uv venv venv --python 3.11 --seed
+    ```
+- Add the `--uv` flag to `webui-user.bat`
+
+</details>
+
+<details>
+<summary>Standard Method</summary>
+
+- Install **[Python 3.11.9](https://www.python.org/downloads/release/python-3119/)**
+    - Remember to enable `Add Python to PATH`
+
+</details>
+
+3. **(Optional)** Configure [Commandline](#commandline)
+4. Launch the WebUI via `webui-user.bat`
+5. During the first launch, it will automatically install all the requirements
+6. Once the installation is finished, the WebUI will start in a browser automatically
+
+<br>
+
+### Install cublas
+
+<details>
+<summary>Expand</summary>
+
+0. Ensure the WebUI can properly launch already, by following the [installation](#installation) steps first
+1. Open the console in the WebUI directory
+    ```bash
+    cd sd-webui-forge-classic
+    ```
+2. Start the virtual environment
+    ```bash
+    venv\scripts\activate
+    ```
+3. Create a new folder
+    ```bash
+    mkdir repo
+    cd repo
+    ```
+4. Clone the repo
+    ```bash
+    git clone https://github.com/aredden/torch-cublas-hgemm
+    cd torch-cublas-hgemm
+    ```
+5. Install the library
+    ```
+    pip install -e . --no-build-isolation
+    ```
+
+    - If you installed `uv`, use `uv pip install` instead
+    - The installation takes a few minutes
+
+</details>
+
+### Install triton
+
+<details>
+<summary>Expand</summary>
+
+0. Ensure the WebUI can properly launch already, by following the [installation](#installation) steps first
+1. Open the console in the WebUI directory
+    ```bash
+    cd sd-webui-forge-classic
+    ```
+2. Start the virtual environment
+    ```bash
+    venv\scripts\activate
+    ```
+3. Install the library
+    - **Windows**
+        ```bash
+        pip install triton-windows
+        ```
+    - **Linux**
+        ```bash
+        pip install triton
+        ```
+    - If you installed `uv`, use `uv pip install` instead
+
+</details>
+
+### Install flash-attn
+
+<details>
+<summary>Expand</summary>
+
+0. Ensure the WebUI can properly launch already, by following the [installation](#installation) steps first
+1. Open the console in the WebUI directory
+    ```bash
+    cd sd-webui-forge-classic
+    ```
+2. Start the virtual environment
+    ```bash
+    venv\scripts\activate
+    ```
+3. Install the library
+    - **Windows**
+        - Download the pre-built `.whl` package from https://github.com/kingbri1/flash-attention/releases
+        ```bash
+        pip install flash_attn...win...whl
+        ```
+    - **Linux**
+        - Download the pre-built `.whl` package from https://github.com/Dao-AILab/flash-attention/releases
+        ```bash
+        pip install flash_attn...linux...whl
+        ```
+    - If you installed `uv`, use `uv pip install` instead
+    - **Important:** Download the correct `.whl` for your Python and PyTorch version
+
+</details>
+
+### Install sageattention 2
+> If you only use **SDXL**, then `1.x` is already enough; `2.x` simply has partial support for **SD1** checkpoints
+
+<details>
+<summary>Expand</summary>
+
+0. Ensure the WebUI can properly launch already, by following the [installation](#installation) steps first
+1. Open the console in the WebUI directory
+    ```bash
+    cd sd-webui-forge-classic
+    ```
+2. Start the virtual environment
+    ```bash
+    venv\scripts\activate
+    ```
+3. Create a new folder
+    ```bash
+    mkdir repo
+    cd repo
+    ```
+4. Clone the repo
+    ```bash
+    git clone https://github.com/thu-ml/SageAttention
+    cd SageAttention
+    ```
+5. Install the library
+    ```
+    pip install -e . --no-build-isolation
+    ```
+
+    - If you installed `uv`, use `uv pip install` instead
+    - The installation takes a few minutes
+
+</details>
+
+<br>
+
+### Install older PyTorch
+> Read this if your GPU does not support the latest PyTorch
+
+<details>
+<summary>Expand</summary>
+
+0. Navigate to the WebUI directory
+1. Edit the `webui-user.bat` file
+2. Add a new line to specify an older version:
+```bash
+set TORCH_COMMAND=pip install torch==2.1.2 torchvision==0.16.2 --extra-index-url https://download.pytorch.org/whl/cu121
+```
+
+</details>
+
+<br>
+
+## Attention
+
+> [!Important]
+> The `--xformers` and `--sage` args are only responsible for installing the packages, **not** whether its respective attention is used; This also means you can remove them once they are successfully installed
+
+**Forge Classic** tries to import the packages and automatically choose the first available attention function in the following order:
+
+1. `SageAttention`
+2. `FlashAttention`
+3. `xformers`
+4. `PyTorch`
+5. `Basic`
+
+> [!Note]
+> The VAE only checks for `xformers`
+
+In my experience, the speed of each attention function for SDXL is ranked in the following order:
+
+- `SageAttention` ≥ `FlashAttention` > `xformers` > `PyTorch` >> `Basic`
+
+> [!Note]
+> `SageAttention` is based on quantization, so its quality might be slightly worse than others
+
+## Issues & Requests
+
+- **Issues** about removed features will simply be ignored
+- **Issues** regarding installation will be ignored if it's obviously user-error
+- **Feature Request** not related to performance or optimization will simply be ignored
+    - For cutting edge features, check out [reForge](https://github.com/Panchovix/stable-diffusion-webui-reForge) instead
+    - Non-Windows platforms will not be supported, as I cannot verify nor maintain them
+
+</details>
+
+<hr>
+
+<p align="center">
+Special thanks to <b>AUTOMATIC1111</b>, <b>lllyasviel</b>, and <b>comfyanonymous</b>, <b>kijai</b>, <br>
+along with the rest of the contributors, <br>
+for their invaluable efforts in the open-source image generation community
+</p>

configs/sd_xl_base.yaml

@@ -0,0 +1,98 @@
+model:
+  target: sgm.models.diffusion.DiffusionEngine
+  params:
+    scale_factor: 0.13025
+    disable_first_stage_autocast: True
+
+    denoiser_config:
+      target: sgm.modules.diffusionmodules.denoiser.DiscreteDenoiser
+      params:
+        num_idx: 1000
+
+        weighting_config:
+          target: sgm.modules.diffusionmodules.denoiser_weighting.EpsWeighting
+        scaling_config:
+          target: sgm.modules.diffusionmodules.denoiser_scaling.EpsScaling
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+
+    network_config:
+      target: sgm.modules.diffusionmodules.openaimodel.UNetModel
+      params:
+        adm_in_channels: 2816
+        num_classes: sequential
+        use_checkpoint: False
+        in_channels: 4
+        out_channels: 4
+        model_channels: 320
+        attention_resolutions: [4, 2]
+        num_res_blocks: 2
+        channel_mult: [1, 2, 4]
+        num_head_channels: 64
+        use_spatial_transformer: True
+        use_linear_in_transformer: True
+        transformer_depth: [1, 2, 10] # note: the first is unused (due to attn_res starting at 2) 32, 16, 8 --> 64, 32, 16
+        context_dim: 2048
+        spatial_transformer_attn_type: softmax-xformers
+        legacy: False
+
+    conditioner_config:
+      target: sgm.modules.GeneralConditioner
+      params:
+        emb_models:
+          # crossattn cond
+          - is_trainable: False
+            input_key: txt
+            target: sgm.modules.encoders.modules.FrozenCLIPEmbedder
+            params:
+              layer: hidden
+              layer_idx: 11
+          # crossattn and vector cond
+          - is_trainable: False
+            input_key: txt
+            target: sgm.modules.encoders.modules.FrozenOpenCLIPEmbedder2
+            params:
+              arch: ViT-bigG-14
+              version: laion2b_s39b_b160k
+              freeze: True
+              layer: penultimate
+              always_return_pooled: True
+              legacy: False
+          # vector cond
+          - is_trainable: False
+            input_key: original_size_as_tuple
+            target: sgm.modules.encoders.modules.ConcatTimestepEmbedderND
+            params:
+              outdim: 256 # multiplied by two
+          # vector cond
+          - is_trainable: False
+            input_key: crop_coords_top_left
+            target: sgm.modules.encoders.modules.ConcatTimestepEmbedderND
+            params:
+              outdim: 256 # multiplied by two
+          # vector cond
+          - is_trainable: False
+            input_key: target_size_as_tuple
+            target: sgm.modules.encoders.modules.ConcatTimestepEmbedderND
+            params:
+              outdim: 256 # multiplied by two
+
+    first_stage_config:
+      target: sgm.models.autoencoder.AutoencoderKLInferenceWrapper
+      params:
+        embed_dim: 4
+        monitor: val/rec_loss
+        ddconfig:
+          attn_type: vanilla-xformers
+          double_z: true
+          z_channels: 4
+          resolution: 256
+          in_channels: 3
+          out_ch: 3
+          ch: 128
+          ch_mult: [1, 2, 4, 4]
+          num_res_blocks: 2
+          attn_resolutions: []
+          dropout: 0.0
+        lossconfig:
+          target: torch.nn.Identity

configs/sd_xl_inpaint.yaml

@@ -0,0 +1,98 @@
+model:
+  target: sgm.models.diffusion.DiffusionEngine
+  params:
+    scale_factor: 0.13025
+    disable_first_stage_autocast: True
+
+    denoiser_config:
+      target: sgm.modules.diffusionmodules.denoiser.DiscreteDenoiser
+      params:
+        num_idx: 1000
+
+        weighting_config:
+          target: sgm.modules.diffusionmodules.denoiser_weighting.EpsWeighting
+        scaling_config:
+          target: sgm.modules.diffusionmodules.denoiser_scaling.EpsScaling
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+
+    network_config:
+      target: sgm.modules.diffusionmodules.openaimodel.UNetModel
+      params:
+        adm_in_channels: 2816
+        num_classes: sequential
+        use_checkpoint: False
+        in_channels: 9
+        out_channels: 4
+        model_channels: 320
+        attention_resolutions: [4, 2]
+        num_res_blocks: 2
+        channel_mult: [1, 2, 4]
+        num_head_channels: 64
+        use_spatial_transformer: True
+        use_linear_in_transformer: True
+        transformer_depth: [1, 2, 10] # note: the first is unused (due to attn_res starting at 2) 32, 16, 8 --> 64, 32, 16
+        context_dim: 2048
+        spatial_transformer_attn_type: softmax-xformers
+        legacy: False
+
+    conditioner_config:
+      target: sgm.modules.GeneralConditioner
+      params:
+        emb_models:
+          # crossattn cond
+          - is_trainable: False
+            input_key: txt
+            target: sgm.modules.encoders.modules.FrozenCLIPEmbedder
+            params:
+              layer: hidden
+              layer_idx: 11
+          # crossattn and vector cond
+          - is_trainable: False
+            input_key: txt
+            target: sgm.modules.encoders.modules.FrozenOpenCLIPEmbedder2
+            params:
+              arch: ViT-bigG-14
+              version: laion2b_s39b_b160k
+              freeze: True
+              layer: penultimate
+              always_return_pooled: True
+              legacy: False
+          # vector cond
+          - is_trainable: False
+            input_key: original_size_as_tuple
+            target: sgm.modules.encoders.modules.ConcatTimestepEmbedderND
+            params:
+              outdim: 256 # multiplied by two
+          # vector cond
+          - is_trainable: False
+            input_key: crop_coords_top_left
+            target: sgm.modules.encoders.modules.ConcatTimestepEmbedderND
+            params:
+              outdim: 256 # multiplied by two
+          # vector cond
+          - is_trainable: False
+            input_key: target_size_as_tuple
+            target: sgm.modules.encoders.modules.ConcatTimestepEmbedderND
+            params:
+              outdim: 256 # multiplied by two
+
+    first_stage_config:
+      target: sgm.models.autoencoder.AutoencoderKLInferenceWrapper
+      params:
+        embed_dim: 4
+        monitor: val/rec_loss
+        ddconfig:
+          attn_type: vanilla-xformers
+          double_z: true
+          z_channels: 4
+          resolution: 256
+          in_channels: 3
+          out_ch: 3
+          ch: 128
+          ch_mult: [1, 2, 4, 4]
+          num_res_blocks: 2
+          attn_resolutions: []
+          dropout: 0.0
+        lossconfig:
+          target: torch.nn.Identity

configs/sd_xl_refiner.yaml

@@ -0,0 +1,91 @@
+model:
+  target: sgm.models.diffusion.DiffusionEngine
+  params:
+    scale_factor: 0.13025
+    disable_first_stage_autocast: True
+
+    denoiser_config:
+      target: sgm.modules.diffusionmodules.denoiser.DiscreteDenoiser
+      params:
+        num_idx: 1000
+
+        weighting_config:
+          target: sgm.modules.diffusionmodules.denoiser_weighting.EpsWeighting
+        scaling_config:
+          target: sgm.modules.diffusionmodules.denoiser_scaling.EpsScaling
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+
+    network_config:
+      target: sgm.modules.diffusionmodules.openaimodel.UNetModel
+      params:
+        adm_in_channels: 2560
+        num_classes: sequential
+        use_checkpoint: False
+        in_channels: 4
+        out_channels: 4
+        model_channels: 384
+        attention_resolutions: [4, 2]
+        num_res_blocks: 2
+        channel_mult: [1, 2, 4, 4]
+        num_head_channels: 64
+        use_spatial_transformer: True
+        use_linear_in_transformer: True
+        transformer_depth: 4
+        context_dim: [1280, 1280, 1280, 1280] # 1280
+        spatial_transformer_attn_type: softmax-xformers
+        legacy: False
+
+    conditioner_config:
+      target: sgm.modules.GeneralConditioner
+      params:
+        emb_models:
+          # crossattn and vector cond
+          - is_trainable: False
+            input_key: txt
+            target: sgm.modules.encoders.modules.FrozenOpenCLIPEmbedder2
+            params:
+              arch: ViT-bigG-14
+              version: laion2b_s39b_b160k
+              freeze: True
+              layer: penultimate
+              always_return_pooled: True
+              legacy: False
+          # vector cond
+          - is_trainable: False
+            input_key: original_size_as_tuple
+            target: sgm.modules.encoders.modules.ConcatTimestepEmbedderND
+            params:
+              outdim: 256 # multiplied by two
+          # vector cond
+          - is_trainable: False
+            input_key: crop_coords_top_left
+            target: sgm.modules.encoders.modules.ConcatTimestepEmbedderND
+            params:
+              outdim: 256 # multiplied by two
+          # vector cond
+          - is_trainable: False
+            input_key: aesthetic_score
+            target: sgm.modules.encoders.modules.ConcatTimestepEmbedderND
+            params:
+              outdim: 256 # multiplied by one
+
+    first_stage_config:
+      target: sgm.models.autoencoder.AutoencoderKLInferenceWrapper
+      params:
+        embed_dim: 4
+        monitor: val/rec_loss
+        ddconfig:
+          attn_type: vanilla-xformers
+          double_z: true
+          z_channels: 4
+          resolution: 256
+          in_channels: 3
+          out_ch: 3
+          ch: 128
+          ch_mult: [1, 2, 4, 4]
+          num_res_blocks: 2
+          attn_resolutions: []
+          dropout: 0.0
+        lossconfig:
+          target: torch.nn.Identity

configs/sd_xl_v.yaml

@@ -0,0 +1,98 @@
+model:
+  target: sgm.models.diffusion.DiffusionEngine
+  params:
+    scale_factor: 0.13025
+    disable_first_stage_autocast: True
+
+    denoiser_config:
+      target: sgm.modules.diffusionmodules.denoiser.DiscreteDenoiser
+      params:
+        num_idx: 1000
+
+        weighting_config:
+          target: sgm.modules.diffusionmodules.denoiser_weighting.VWeighting
+        scaling_config:
+          target: sgm.modules.diffusionmodules.denoiser_scaling.VScaling
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+
+    network_config:
+      target: sgm.modules.diffusionmodules.openaimodel.UNetModel
+      params:
+        adm_in_channels: 2816
+        num_classes: sequential
+        use_checkpoint: False
+        in_channels: 4
+        out_channels: 4
+        model_channels: 320
+        attention_resolutions: [4, 2]
+        num_res_blocks: 2
+        channel_mult: [1, 2, 4]
+        num_head_channels: 64
+        use_spatial_transformer: True
+        use_linear_in_transformer: True
+        transformer_depth: [1, 2, 10] # note: the first is unused (due to attn_res starting at 2) 32, 16, 8 --> 64, 32, 16
+        context_dim: 2048
+        spatial_transformer_attn_type: softmax-xformers
+        legacy: False
+
+    conditioner_config:
+      target: sgm.modules.GeneralConditioner
+      params:
+        emb_models:
+          # crossattn cond
+          - is_trainable: False
+            input_key: txt
+            target: sgm.modules.encoders.modules.FrozenCLIPEmbedder
+            params:
+              layer: hidden
+              layer_idx: 11
+          # crossattn and vector cond
+          - is_trainable: False
+            input_key: txt
+            target: sgm.modules.encoders.modules.FrozenOpenCLIPEmbedder2
+            params:
+              arch: ViT-bigG-14
+              version: laion2b_s39b_b160k
+              freeze: True
+              layer: penultimate
+              always_return_pooled: True
+              legacy: False
+          # vector cond
+          - is_trainable: False
+            input_key: original_size_as_tuple
+            target: sgm.modules.encoders.modules.ConcatTimestepEmbedderND
+            params:
+              outdim: 256 # multiplied by two
+          # vector cond
+          - is_trainable: False
+            input_key: crop_coords_top_left
+            target: sgm.modules.encoders.modules.ConcatTimestepEmbedderND
+            params:
+              outdim: 256 # multiplied by two
+          # vector cond
+          - is_trainable: False
+            input_key: target_size_as_tuple
+            target: sgm.modules.encoders.modules.ConcatTimestepEmbedderND
+            params:
+              outdim: 256 # multiplied by two
+
+    first_stage_config:
+      target: sgm.models.autoencoder.AutoencoderKLInferenceWrapper
+      params:
+        embed_dim: 4
+        monitor: val/rec_loss
+        ddconfig:
+          attn_type: vanilla-xformers
+          double_z: true
+          z_channels: 4
+          resolution: 256
+          in_channels: 3
+          out_ch: 3
+          ch: 128
+          ch_mult: [1, 2, 4, 4]
+          num_res_blocks: 2
+          attn_resolutions: []
+          dropout: 0.0
+        lossconfig:
+          target: torch.nn.Identity

configs/v1-inference.yaml

@@ -0,0 +1,69 @@
+model:
+  target: ldm.models.diffusion.ddpm.LatentDiffusion
+  params:
+    linear_start: 0.00085
+    linear_end: 0.0120
+    num_timesteps_cond: 1
+    log_every_t: 200
+    timesteps: 1000
+    first_stage_key: "jpg"
+    cond_stage_key: "txt"
+    image_size: 64
+    channels: 4
+    cond_stage_trainable: false # Note: different from the one we trained before
+    conditioning_key: crossattn
+    monitor: val/loss_simple_ema
+    scale_factor: 0.18215
+    use_ema: False
+
+    scheduler_config: # 10000 warmup steps
+      target: ldm.lr_scheduler.LambdaLinearScheduler
+      params:
+        warm_up_steps: [10000]
+        cycle_lengths: [10000000000000] # incredibly large number to prevent corner cases
+        f_start: [1.e-6]
+        f_max: [1.]
+        f_min: [1.]
+
+    unet_config:
+      target: ldm.modules.diffusionmodules.openaimodel.UNetModel
+      params:
+        image_size: 32 # unused
+        in_channels: 4
+        out_channels: 4
+        model_channels: 320
+        attention_resolutions: [4, 2, 1]
+        num_res_blocks: 2
+        channel_mult: [1, 2, 4, 4]
+        num_heads: 8
+        use_spatial_transformer: True
+        transformer_depth: 1
+        context_dim: 768
+        use_checkpoint: False
+        legacy: False
+
+    first_stage_config:
+      target: ldm.models.autoencoder.AutoencoderKL
+      params:
+        embed_dim: 4
+        monitor: val/rec_loss
+        ddconfig:
+          double_z: true
+          z_channels: 4
+          resolution: 256
+          in_channels: 3
+          out_ch: 3
+          ch: 128
+          ch_mult:
+            - 1
+            - 2
+            - 4
+            - 4
+          num_res_blocks: 2
+          attn_resolutions: []
+          dropout: 0.0
+        lossconfig:
+          target: torch.nn.Identity
+
+    cond_stage_config:
+      target: ldm.modules.encoders.modules.FrozenCLIPEmbedder

configs/v1-inpainting-inference.yaml

@@ -0,0 +1,69 @@
+model:
+  target: ldm.models.diffusion.ddpm.LatentInpaintDiffusion
+  params:
+    linear_start: 0.00085
+    linear_end: 0.0120
+    num_timesteps_cond: 1
+    log_every_t: 200
+    timesteps: 1000
+    first_stage_key: "jpg"
+    cond_stage_key: "txt"
+    image_size: 64
+    channels: 4
+    cond_stage_trainable: false # Note: different from the one we trained before
+    conditioning_key: hybrid # important
+    monitor: val/loss_simple_ema
+    scale_factor: 0.18215
+    finetune_keys: null
+
+    scheduler_config: # 10000 warmup steps
+      target: ldm.lr_scheduler.LambdaLinearScheduler
+      params:
+        warm_up_steps: [2500] # NOTE for resuming. use 10000 if starting from scratch
+        cycle_lengths: [10000000000000] # incredibly large number to prevent corner cases
+        f_start: [1.e-6]
+        f_max: [1.]
+        f_min: [1.]
+
+    unet_config:
+      target: ldm.modules.diffusionmodules.openaimodel.UNetModel
+      params:
+        image_size: 32 # unused
+        in_channels: 9 # 4 data + 4 downscaled image + 1 mask
+        out_channels: 4
+        model_channels: 320
+        attention_resolutions: [4, 2, 1]
+        num_res_blocks: 2
+        channel_mult: [1, 2, 4, 4]
+        num_heads: 8
+        use_spatial_transformer: True
+        transformer_depth: 1
+        context_dim: 768
+        use_checkpoint: False
+        legacy: False
+
+    first_stage_config:
+      target: ldm.models.autoencoder.AutoencoderKL
+      params:
+        embed_dim: 4
+        monitor: val/rec_loss
+        ddconfig:
+          double_z: true
+          z_channels: 4
+          resolution: 256
+          in_channels: 3
+          out_ch: 3
+          ch: 128
+          ch_mult:
+            - 1
+            - 2
+            - 4
+            - 4
+          num_res_blocks: 2
+          attn_resolutions: []
+          dropout: 0.0
+        lossconfig:
+          target: torch.nn.Identity
+
+    cond_stage_config:
+      target: ldm.modules.encoders.modules.FrozenCLIPEmbedder

environment-wsl2.yaml

@@ -0,0 +1,11 @@
+name: forge-classic
+channels:
+  - pytorch
+  - defaults
+dependencies:
+  - python=3.10
+  - pip=24.0
+  - cudatoolkit=11.8
+  - pytorch=2.5
+  - torchvision=0.20
+  - numpy=1.26

extensions-builtin/Lora/extra_networks_lora.py

@@ -0,0 +1,67 @@
+from modules import extra_networks, shared
+
+import networks
+
+
+class ExtraNetworkLora(extra_networks.ExtraNetwork):
+    def __init__(self):
+        super().__init__("lora")
+
+        self.errors = {}
+        """mapping of network names to the number of errors the network had during operation"""
+
+    def activate(self, p, params_list):
+        additional = shared.opts.sd_lora
+
+        self.errors.clear()
+
+        if additional != "None" and additional in networks.available_networks and not any(x for x in params_list if x.items[0] == additional):
+            p.all_prompts = [x + f"<lora:{additional}:{shared.opts.extra_networks_default_multiplier}>" for x in p.all_prompts]
+            params_list.append(extra_networks.ExtraNetworkParams(items=[additional, shared.opts.extra_networks_default_multiplier]))
+
+        names = []
+        te_multipliers = []
+        unet_multipliers = []
+        dyn_dims = []
+        for params in params_list:
+            assert params.items
+
+            names.append(params.positional[0])
+
+            te_multiplier = float(params.positional[1]) if len(params.positional) > 1 else 1.0
+            te_multiplier = float(params.named.get("te", te_multiplier))
+
+            unet_multiplier = float(params.positional[2]) if len(params.positional) > 2 else te_multiplier
+            unet_multiplier = float(params.named.get("unet", unet_multiplier))
+
+            dyn_dim = int(params.positional[3]) if len(params.positional) > 3 else None
+            dyn_dim = int(params.named["dyn"]) if "dyn" in params.named else dyn_dim
+
+            te_multipliers.append(te_multiplier)
+            unet_multipliers.append(unet_multiplier)
+            dyn_dims.append(dyn_dim)
+
+        networks.load_networks(names, te_multipliers, unet_multipliers, dyn_dims)
+
+        if shared.opts.lora_add_hashes_to_infotext:
+            network_hashes = []
+            for item in networks.loaded_networks:
+                shorthash = item.network_on_disk.shorthash
+                if not shorthash:
+                    continue
+
+                alias = item.mentioned_name
+                if not alias:
+                    continue
+
+                alias = alias.replace(":", "").replace(",", "")
+
+                network_hashes.append(f"{alias}: {shorthash}")
+
+            if network_hashes:
+                p.extra_generation_params["Lora hashes"] = ", ".join(network_hashes)
+
+    def deactivate(self, p):
+        if self.errors:
+            p.comment("Networks with errors: " + ", ".join(f"{k} ({v})" for k, v in self.errors.items()))
+            self.errors.clear()

extensions-builtin/Lora/lora.py

@@ -0,0 +1,9 @@
+import networks
+
+list_available_loras = networks.list_available_networks
+
+available_loras = networks.available_networks
+available_lora_aliases = networks.available_network_aliases
+available_lora_hash_lookup = networks.available_network_hash_lookup
+forbidden_lora_aliases = networks.forbidden_network_aliases
+loaded_loras = networks.loaded_networks

extensions-builtin/Lora/network.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+import enum
+from collections import namedtuple
+
+import torch.nn as nn
+import torch.nn.functional as F
+from modules import cache, errors, hashes, sd_models, shared
+
+NetworkWeights = namedtuple("NetworkWeights", ["network_key", "sd_key", "w", "sd_module"])
+
+metadata_tags_order = {
+    "ss_sd_model_name": 1,
+    "ss_resolution": 2,
+    "ss_clip_skip": 3,
+    "ss_num_train_images": 10,
+    "ss_tag_frequency": 20,
+}
+
+
+class SDVersion(enum.Enum):
+    Unknown = -1
+    SD1 = 1
+    SD2 = 2
+    SDXL = 3
+
+
+class NetworkOnDisk:
+    def __init__(self, name, filename):
+        self.name = name
+        self.filename = filename
+        self.metadata = {}
+        self.is_safetensors = filename.lower().endswith(".safetensors")
+
+        def read_metadata():
+            metadata = sd_models.read_metadata_from_safetensors(filename)
+            metadata.pop("ssmd_cover_images", None)  # cover images are too big to display in UI
+            return metadata
+
+        if self.is_safetensors:
+            try:
+                self.metadata = cache.cached_data_for_file("safetensors-metadata", "/".join(["lora", self.name]), filename, read_metadata)
+            except Exception as e:
+                errors.display(e, f"reading lora {filename}")
+
+        if self.metadata:
+            m = {}
+            for k, v in sorted(self.metadata.items(), key=lambda x: metadata_tags_order.get(x[0], 999)):
+                m[k] = v
+
+            self.metadata = m
+
+        self.alias = self.metadata.get("ss_output_name", self.name)
+
+        self.hash = None
+        self.shorthash = None
+        self.set_hash(self.metadata.get("sshs_model_hash") or hashes.sha256_from_cache(self.filename, "/".join(["lora", self.name]), use_addnet_hash=self.is_safetensors) or "")
+
+        self.sd_version = self.detect_version()
+
+    def detect_version(self):
+        if str(self.metadata.get("ss_base_model_version", "")).startswith("sdxl_"):
+            return SDVersion.SDXL
+        elif str(self.metadata.get("ss_v2", "")) == "True":
+            return SDVersion.SD2
+        elif len(self.metadata):
+            return SDVersion.SD1
+
+        return SDVersion.Unknown
+
+    def set_hash(self, v):
+        self.hash = v
+        self.shorthash = self.hash[0:12]
+
+        if self.shorthash:
+            import networks
+
+            networks.available_network_hash_lookup[self.shorthash] = self
+
+    def read_hash(self):
+        if not self.hash:
+            self.set_hash(
+                hashes.sha256(
+                    self.filename,
+                    "/".join(["lora", self.name]),
+                    use_addnet_hash=self.is_safetensors,
+                )
+                or ""
+            )
+
+    def get_alias(self):
+        import networks
+
+        if shared.opts.lora_preferred_name == "Filename" or self.alias.lower() in networks.forbidden_network_aliases:
+            return self.name
+        else:
+            return self.alias
+
+
+class Network:  # LoraModule
+    def __init__(self, name, network_on_disk: NetworkOnDisk):
+        self.name = name
+        self.network_on_disk = network_on_disk
+        self.te_multiplier = 1.0
+        self.unet_multiplier = 1.0
+        self.dyn_dim = None
+        self.modules = {}
+        self.bundle_embeddings = {}
+        self.mtime = None
+
+        self.mentioned_name = None
+        """the text that was used to add the network to prompt - can be either name or an alias"""
+
+
+class ModuleType:
+    def create_module(self, net: Network, weights: NetworkWeights) -> Network | None:
+        return None
+
+
+class NetworkModule:
+    def __init__(self, net: Network, weights: NetworkWeights):
+        self.network = net
+        self.network_key = weights.network_key
+        self.sd_key = weights.sd_key
+        self.sd_module = weights.sd_module
+
+        if hasattr(self.sd_module, "weight"):
+            self.shape = self.sd_module.weight.shape
+
+        self.ops = None
+        self.extra_kwargs = {}
+        if isinstance(self.sd_module, nn.Conv2d):
+            self.ops = F.conv2d
+            self.extra_kwargs = {
+                "stride": self.sd_module.stride,
+                "padding": self.sd_module.padding,
+            }
+        elif isinstance(self.sd_module, nn.Linear):
+            self.ops = F.linear
+        elif isinstance(self.sd_module, nn.LayerNorm):
+            self.ops = F.layer_norm
+            self.extra_kwargs = {
+                "normalized_shape": self.sd_module.normalized_shape,
+                "eps": self.sd_module.eps,
+            }
+        elif isinstance(self.sd_module, nn.GroupNorm):
+            self.ops = F.group_norm
+            self.extra_kwargs = {
+                "num_groups": self.sd_module.num_groups,
+                "eps": self.sd_module.eps,
+            }
+
+        self.dim = None
+        self.bias = weights.w.get("bias")
+        self.alpha = weights.w["alpha"].item() if "alpha" in weights.w else None
+        self.scale = weights.w["scale"].item() if "scale" in weights.w else None
+
+    def multiplier(self):
+        if "transformer" in self.sd_key[:20]:
+            return self.network.te_multiplier
+        else:
+            return self.network.unet_multiplier
+
+    def calc_scale(self):
+        if self.scale is not None:
+            return self.scale
+        if self.dim is not None and self.alpha is not None:
+            return self.alpha / self.dim
+
+        return 1.0
+
+    def finalize_updown(self, updown, orig_weight, output_shape, ex_bias=None):
+        if self.bias is not None:
+            updown = updown.reshape(self.bias.shape)
+            updown += self.bias.to(orig_weight.device, dtype=updown.dtype)
+            updown = updown.reshape(output_shape)
+
+        if len(output_shape) == 4:
+            updown = updown.reshape(output_shape)
+
+        if orig_weight.size().numel() == updown.size().numel():
+            updown = updown.reshape(orig_weight.shape)
+
+        if ex_bias is not None:
+            ex_bias = ex_bias * self.multiplier()
+
+        return updown * self.calc_scale() * self.multiplier(), ex_bias
+
+    def calc_updown(self, target):
+        raise NotImplementedError
+
+    def forward(self, x, y):
+        """A general forward implementation for all modules"""
+        if self.ops is None:
+            raise NotImplementedError
+
+        updown, ex_bias = self.calc_updown(self.sd_module.weight)
+        return y + self.ops(x, weight=updown, bias=ex_bias, **self.extra_kwargs)

extensions-builtin/Lora/networks.py

@@ -0,0 +1,150 @@
+import functools
+import os.path
+import re
+
+from ldm_patched.modules.sd import load_lora_for_models
+from ldm_patched.modules.utils import load_torch_file
+from modules import errors, scripts, sd_models, shared
+
+import network
+
+
+@functools.lru_cache(maxsize=4, typed=False)
+def load_lora_state_dict(filename):
+    return load_torch_file(filename, safe_load=True)
+
+
+def load_network(name, network_on_disk):
+    net = network.Network(name, network_on_disk)
+    net.mtime = os.path.getmtime(network_on_disk.filename)
+    return net
+
+
+def load_networks(names, te_multipliers=None, unet_multipliers=None, dyn_dims=None):
+    global lora_state_dict_cache
+
+    current_sd = sd_models.model_data.get_sd_model()
+    if current_sd is None:
+        return
+
+    loaded_networks.clear()
+
+    networks_on_disk = [(available_networks.get(name, None) if name.lower() in forbidden_network_aliases else available_network_aliases.get(name, None)) for name in names]
+    assert not any(x is None for x in networks_on_disk)
+
+    for network_on_disk, name in zip(networks_on_disk, names):
+        try:
+            net = load_network(name, network_on_disk)
+        except Exception as e:
+            errors.display(e, f"loading network {network_on_disk.filename}")
+            continue
+        net.mentioned_name = name
+        network_on_disk.read_hash()
+        loaded_networks.append(net)
+
+    compiled_lora_targets = []
+    for a, b, c in zip(networks_on_disk, unet_multipliers, te_multipliers):
+        compiled_lora_targets.append([a.filename, b, c])
+
+    compiled_lora_targets_hash = str(compiled_lora_targets)
+
+    if current_sd.current_lora_hash == compiled_lora_targets_hash:
+        return
+
+    current_sd.current_lora_hash = compiled_lora_targets_hash
+    current_sd.forge_objects.unet = current_sd.forge_objects_original.unet
+    current_sd.forge_objects.clip = current_sd.forge_objects_original.clip
+
+    for filename, strength_model, strength_clip in compiled_lora_targets:
+        lora_sd = load_lora_state_dict(filename)
+        current_sd.forge_objects.unet, current_sd.forge_objects.clip = load_lora_for_models(
+            current_sd.forge_objects.unet,
+            current_sd.forge_objects.clip,
+            lora_sd,
+            strength_model,
+            strength_clip,
+            filename,
+        )
+
+    current_sd.forge_objects_after_applying_lora = current_sd.forge_objects.shallow_copy()
+
+
+def list_available_networks():
+    available_networks.clear()
+    available_network_aliases.clear()
+    available_network_hash_lookup.clear()
+    forbidden_network_aliases.clear()
+    forbidden_network_aliases.update({"none": 1, "Addams": 1})
+
+    candidates = list(
+        shared.walk_files(
+            shared.cmd_opts.lora_dir,
+            allowed_extensions=[".pt", ".ckpt", ".safetensors"],
+        )
+    )
+
+    for filename in candidates:
+        if os.path.isdir(filename):
+            continue
+
+        name = os.path.splitext(os.path.basename(filename))[0]
+        try:
+            entry = network.NetworkOnDisk(name, filename)
+        except OSError:  # should catch FileNotFoundError and PermissionError, etc.
+            errors.report(f"Failed to load network {name} from {filename}", exc_info=True)
+            continue
+
+        available_networks[name] = entry
+
+        if entry.alias in available_network_aliases:
+            forbidden_network_aliases[entry.alias.lower()] = 1
+
+        available_network_aliases[name] = entry
+        available_network_aliases[entry.alias] = entry
+
+
+re_network_name = re.compile(r"(.*)\s*\([0-9a-fA-F]+\)")
+
+
+def infotext_pasted(infotext, params):
+    if "AddNet Module 1" in [x[1] for x in scripts.scripts_txt2img.infotext_fields]:
+        return  # if the other extension is active, it will handle those fields, no need to do anything
+
+    added = []
+
+    for k in params:
+        if not k.startswith("AddNet Model "):
+            continue
+
+        num = k[13:]
+
+        if params.get("AddNet Module " + num) != "LoRA":
+            continue
+
+        name = params.get("AddNet Model " + num)
+        if name is None:
+            continue
+
+        m = re_network_name.match(name)
+        if m:
+            name = m.group(1)
+
+        multiplier = params.get("AddNet Weight A " + num, "1.0")
+
+        added.append(f"<lora:{name}:{multiplier}>")
+
+    if added:
+        params["Prompt"] += "\n" + "".join(added)
+
+
+extra_network_lora = None
+
+available_networks = {}
+available_network_aliases = {}
+loaded_networks = []
+loaded_bundle_embeddings = {}
+networks_in_memory = {}
+available_network_hash_lookup = {}
+forbidden_network_aliases = {}
+
+list_available_networks()

extensions-builtin/Lora/preload.py

@@ -0,0 +1,13 @@
+from os.path import join
+
+from modules import paths
+from modules.paths_internal import normalized_filepath
+
+
+def preload(parser):
+    parser.add_argument(
+        "--lora-dir",
+        type=normalized_filepath,
+        help="Path to directory with LoRA networks",
+        default=join(paths.models_path, "Lora"),
+    )

extensions-builtin/Lora/scripts/lora_script.py

@@ -0,0 +1,83 @@
+import re
+
+import gradio as gr
+from fastapi import FastAPI
+from modules import extra_networks, script_callbacks, shared, ui_extra_networks
+
+import extra_networks_lora
+import lora  # noqa: F401
+import network
+import networks
+import ui_extra_networks_lora
+
+shared.options_templates.update(
+    shared.options_section(
+        ("extra_networks", "Extra Networks"),
+        {
+            "sd_lora": shared.OptionInfo("None", "Add network to prompt", gr.Dropdown, lambda: {"choices": ["None", *networks.available_networks]}, refresh=networks.list_available_networks),
+            "lora_preferred_name": shared.OptionInfo("Alias from file", "When adding to prompt, refer to Lora by", gr.Radio, {"choices": ["Alias from file", "Filename"]}),
+            "lora_add_hashes_to_infotext": shared.OptionInfo(True, "Add Lora hashes to infotext"),
+            "lora_show_all": shared.OptionInfo(False, "Always show all networks on the Lora page").info("otherwise, those detected as for incompatible version of Stable Diffusion will be hidden"),
+            "lora_hide_unknown_for_versions": shared.OptionInfo([], "Hide networks of unknown versions for model versions", gr.CheckboxGroup, {"choices": ["SD1", "SD2", "SDXL"]}),
+        },
+    )
+)
+
+
+if shared.cmd_opts.api:
+
+    def create_lora_json(obj: network.NetworkOnDisk):
+        return {
+            "name": obj.name,
+            "alias": obj.alias,
+            "path": obj.filename,
+            "metadata": obj.metadata,
+        }
+
+    def api_networks(_: gr.Blocks, app: FastAPI):
+        @app.get("/sdapi/v1/loras")
+        async def get_loras():
+            return [create_lora_json(obj) for obj in networks.available_networks.values()]
+
+        @app.post("/sdapi/v1/refresh-loras")
+        async def refresh_loras():
+            return networks.list_available_networks()
+
+    script_callbacks.on_app_started(api_networks)
+
+
+re_lora = re.compile("<lora:([^:]+):")
+
+
+def infotext_pasted(infotext, d):
+    hashes = d.get("Lora hashes")
+    if not hashes:
+        return
+
+    hashes = [x.strip().split(":", 1) for x in hashes.split(",")]
+    hashes = {x[0].strip().replace(",", ""): x[1].strip() for x in hashes}
+
+    def network_replacement(m):
+        alias = m.group(1)
+        shorthash = hashes.get(alias)
+        if shorthash is None:
+            return m.group(0)
+
+        network_on_disk = networks.available_network_hash_lookup.get(shorthash)
+        if network_on_disk is None:
+            return m.group(0)
+
+        return f"<lora:{network_on_disk.get_alias()}:"
+
+    d["Prompt"] = re.sub(re_lora, network_replacement, d["Prompt"])
+
+
+def before_ui():
+    ui_extra_networks.register_page(ui_extra_networks_lora.ExtraNetworksPageLora())
+    networks.extra_network_lora = extra_networks_lora.ExtraNetworkLora()
+    extra_networks.register_extra_network(networks.extra_network_lora)
+
+
+script_callbacks.on_before_ui(before_ui)
+script_callbacks.on_infotext_pasted(networks.infotext_pasted)
+script_callbacks.on_infotext_pasted(infotext_pasted)

extensions-builtin/Lora/ui_edit_user_metadata.py

@@ -0,0 +1,217 @@
+import datetime
+import html
+import re
+
+import gradio as gr
+from modules.ui_extra_networks_user_metadata import UserMetadataEditor
+
+re_word = re.compile(r"[-_\w']+")
+re_comma = re.compile(r" *, *")
+
+
+def is_non_comma_tagset(tags):
+    average_tag_length = sum(len(x) for x in tags.keys()) / len(tags)
+    return average_tag_length >= 16
+
+
+def build_tags(metadata):
+    tags = {}
+
+    for _, tags_dict in metadata.get("ss_tag_frequency", {}).items():
+        for tag, tag_count in tags_dict.items():
+            tag = tag.strip()
+            tags[tag] = tags.get(tag, 0) + int(tag_count)
+
+    if tags and is_non_comma_tagset(tags):
+        new_tags = {}
+
+        for text, text_count in tags.items():
+            for word in re.findall(re_word, text):
+                if len(word) < 3:
+                    continue
+
+                new_tags[word] = new_tags.get(word, 0) + text_count
+
+        tags = new_tags
+
+    ordered_tags = sorted(tags.keys(), key=tags.get, reverse=True)
+    return [(tag, tags[tag]) for tag in ordered_tags]
+
+
+class LoraUserMetadataEditor(UserMetadataEditor):
+    def __init__(self, ui, tabname, page):
+        super().__init__(ui, tabname, page)
+
+        self.select_sd_version = None
+
+        self.taginfo = None
+        self.edit_activation_text = None
+        self.slider_preferred_weight = None
+        self.edit_notes = None
+
+    def save_lora_user_metadata(
+        self,
+        name,
+        desc,
+        sd_version,
+        activation_text,
+        preferred_weight,
+        negative_text,
+        notes,
+    ):
+        user_metadata = self.get_user_metadata(name)
+        user_metadata["description"] = desc
+        user_metadata["sd version"] = sd_version
+        user_metadata["activation text"] = activation_text
+        user_metadata["preferred weight"] = preferred_weight
+        user_metadata["negative text"] = negative_text
+        user_metadata["notes"] = notes
+
+        self.write_user_metadata(name, user_metadata)
+
+    def get_metadata_table(self, name):
+        table = super().get_metadata_table(name)
+        item = self.page.items.get(name, {})
+        metadata = item.get("metadata") or {}
+
+        keys = {
+            "ss_output_name": "Output name:",
+            "ss_sd_model_name": "Model:",
+            "ss_clip_skip": "Clip skip:",
+            "ss_network_module": "Kohya module:",
+        }
+
+        for key, label in keys.items():
+            value = metadata.get(key, None)
+            if value is not None and str(value) != "None":
+                table.append((label, html.escape(value)))
+
+        ss_training_started_at = metadata.get("ss_training_started_at")
+        if ss_training_started_at:
+            table.append(
+                (
+                    "Date trained:",
+                    datetime.datetime.fromtimestamp(float(ss_training_started_at)).strftime("%Y-%m-%d %H:%M"),
+                )
+            )
+
+        ss_bucket_info = metadata.get("ss_bucket_info")
+        if ss_bucket_info and "buckets" in ss_bucket_info:
+            resolutions = {}
+            for _, bucket in ss_bucket_info["buckets"].items():
+                resolution = bucket["resolution"]
+                resolution = f"{resolution[1]}x{resolution[0]}"
+                resolutions[resolution] = resolutions.get(resolution, 0) + int(bucket["count"])
+
+            resolutions_list = sorted(resolutions.keys(), key=resolutions.get, reverse=True)
+            resolutions_text = html.escape(", ".join(resolutions_list[0:4]))
+            if len(resolutions) > 4:
+                resolutions_text += ", ..."
+                resolutions_text = f"<span title='{html.escape(', '.join(resolutions_list))}'>{resolutions_text}</span>"
+
+            table.append(
+                (
+                    "Resolutions:" if len(resolutions_list) > 1 else "Resolution:",
+                    resolutions_text,
+                )
+            )
+
+        image_count = 0
+        for _, params in metadata.get("ss_dataset_dirs", {}).items():
+            image_count += int(params.get("img_count", 0))
+
+        if image_count:
+            table.append(("Dataset size:", image_count))
+
+        return table
+
+    def put_values_into_components(self, name):
+        user_metadata = self.get_user_metadata(name)
+        values = super().put_values_into_components(name)
+
+        item = self.page.items.get(name, {})
+        metadata = item.get("metadata") or {}
+
+        tags = build_tags(metadata)
+        gradio_tags = [(tag, str(count)) for tag, count in tags[0:24]]
+
+        return [
+            *values[0:5],
+            gr.update(value=item.get("sd_version", "Unknown")),
+            gr.HighlightedText.update(value=gradio_tags, visible=True if tags else False),
+            user_metadata.get("activation text", ""),
+            float(user_metadata.get("preferred weight", 0.0)),
+            user_metadata.get("negative text", ""),
+        ]
+
+    def create_extra_default_items_in_left_column(self):
+        self.select_sd_version = gr.Dropdown(
+            choices=("SD1", "SD2", "SDXL", "Unknown"),
+            value="Unknown",
+            label="Stable Diffusion Version",
+            interactive=True,
+        )
+
+    def create_editor(self):
+        self.create_default_editor_elems()
+
+        self.taginfo = gr.HighlightedText(label="Training dataset tags")
+        self.edit_activation_text = gr.Text(label="Activation text", info="Will be added to prompt along with Lora")
+        self.edit_negative_text = gr.Text(label="Negative prompt", info="Will be added to negative prompts")
+        self.slider_preferred_weight = gr.Slider(
+            label="Preferred weight",
+            info="Set to 0 to use the default set in Settings",
+            minimum=0.0,
+            maximum=2.0,
+            step=0.1,
+        )
+        self.edit_notes = gr.TextArea(label="Notes", lines=4)
+
+        def select_tag(activation_text, evt: gr.SelectData):
+            tag = evt.value[0]
+
+            words = re.split(re_comma, activation_text)
+            if tag in words:
+                words = [x for x in words if x != tag and x.strip()]
+                return ", ".join(words)
+
+            return activation_text + ", " + tag if activation_text else tag
+
+        self.taginfo.select(
+            fn=select_tag,
+            inputs=[self.edit_activation_text],
+            outputs=[self.edit_activation_text],
+            show_progress=False,
+        )
+
+        self.create_default_buttons()
+
+        viewed_components = [
+            self.edit_name,
+            self.edit_description,
+            self.html_filedata,
+            self.html_preview,
+            self.edit_notes,
+            self.select_sd_version,
+            self.taginfo,
+            self.edit_activation_text,
+            self.slider_preferred_weight,
+            self.edit_negative_text,
+        ]
+
+        self.button_edit.click(
+            fn=self.put_values_into_components,
+            inputs=[self.edit_name_input],
+            outputs=viewed_components,
+        ).then(fn=lambda: gr.update(visible=True), inputs=[], outputs=[self.box])
+
+        edited_components = [
+            self.edit_description,
+            self.select_sd_version,
+            self.edit_activation_text,
+            self.slider_preferred_weight,
+            self.edit_negative_text,
+            self.edit_notes,
+        ]
+
+        self.setup_save_handler(self.button_save, self.save_lora_user_metadata, edited_components)

extensions-builtin/Lora/ui_extra_networks_lora.py

@@ -0,0 +1,94 @@
+from os import makedirs
+from os.path import splitext
+
+from modules import shared
+from modules.ui_extra_networks import ExtraNetworksPage, quote_js
+
+import network
+import networks
+from ui_edit_user_metadata import LoraUserMetadataEditor
+
+
+class ExtraNetworksPageLora(ExtraNetworksPage):
+    def __init__(self):
+        super().__init__("Lora")
+        makedirs(shared.cmd_opts.lora_dir, exist_ok=True)
+
+    def refresh(self):
+        networks.list_available_networks()
+
+    def create_item(self, name, index=None, enable_filter=True):
+        lora_on_disk = networks.available_networks.get(name)
+        if lora_on_disk is None:
+            return
+
+        path = splitext(lora_on_disk.filename)[0]
+        search_terms = [self.search_terms_from_path(lora_on_disk.filename)]
+        if lora_on_disk.hash:
+            search_terms.append(lora_on_disk.hash)
+
+        item = {
+            "name": name,
+            "filename": lora_on_disk.filename,
+            "shorthash": lora_on_disk.shorthash,
+            "preview": self.find_preview(path),
+            "description": self.find_description(path),
+            "search_terms": search_terms,
+            "local_preview": f"{path}.{shared.opts.samples_format}",
+            "metadata": lora_on_disk.metadata,
+            "sort_keys": {
+                "default": index,
+                **self.get_sort_keys(lora_on_disk.filename),
+            },
+            "sd_version": lora_on_disk.sd_version.name,
+        }
+
+        self.read_user_metadata(item)
+
+        sd_version = item["user_metadata"].get("sd version")
+        if sd_version in network.SDVersion.__members__:
+            item["sd_version"] = sd_version
+            sd_version = network.SDVersion[sd_version]
+        else:
+            sd_version = lora_on_disk.sd_version
+
+        if enable_filter and not shared.opts.lora_show_all:
+            if sd_version is network.SDVersion.Unknown:
+                model_version = network.SDVersion.SDXL if shared.sd_model.is_sdxl else network.SDVersion.SD1
+                if model_version.name in shared.opts.lora_hide_unknown_for_versions:
+                    return None
+            elif shared.sd_model.is_sdxl and sd_version != network.SDVersion.SDXL:
+                return None
+            elif shared.sd_model.is_sd2 and sd_version != network.SDVersion.SD2:
+                return None
+            elif shared.sd_model.is_sd1 and sd_version != network.SDVersion.SD1:
+                return None
+
+        alias = lora_on_disk.get_alias()
+        activation_text = item["user_metadata"].get("activation text")
+        preferred_weight = item["user_metadata"].get("preferred weight", 0.0)
+        item["prompt"] = quote_js(f"<lora:{alias}:") + " + " + (str(preferred_weight) if preferred_weight else "opts.extra_networks_default_multiplier") + " + " + quote_js(">")
+
+        if activation_text:
+            item["prompt"] += " + " + quote_js(" " + activation_text)
+
+        negative_prompt = item["user_metadata"].get("negative text")
+        item["negative_prompt"] = quote_js("")
+        if negative_prompt:
+            item["negative_prompt"] = quote_js("(" + negative_prompt + ":1)")
+
+        return item
+
+    def list_items(self):
+        """instantiate a list to protect against concurrent modification"""
+        names = list(networks.available_networks)
+        for index, name in enumerate(names):
+            item = self.create_item(name, index)
+            if item is not None:
+                yield item
+
+    def allowed_directories_for_previews(self):
+        return [shared.cmd_opts.lora_dir]
+
+    def create_user_metadata_editor(self, ui, tabname):
+        return LoraUserMetadataEditor(ui, tabname, self)

extensions-builtin/canvas-zoom-and-pan/javascript/zoom.js

@@ -0,0 +1,940 @@
+(function () {
+
+    onUiLoaded(async () => {
+        const elementIDs = {
+            img2imgTabs: "#mode_img2img .tab-nav",
+            inpaint: "#img2maskimg",
+            inpaintSketch: "#inpaint_sketch",
+            rangeGroup: "#img2img_column_size",
+            sketch: "#img2img_sketch"
+        };
+
+        const tabNameToElementId = {
+            "Inpaint sketch": elementIDs.inpaintSketch,
+            "Inpaint": elementIDs.inpaint,
+            "Sketch": elementIDs.sketch
+        };
+
+        /** Waits for an element to be present in the DOM */
+        const waitForElement = (id) => new Promise(resolve => {
+            const checkForElement = () => {
+                const element = document.querySelector(id);
+                if (element) return resolve(element);
+                setTimeout(checkForElement, 100);
+            };
+            checkForElement();
+        });
+
+        function getActiveTab(elements, all = false) {
+            const tabs = elements.img2imgTabs.querySelectorAll("button");
+            if (all) return tabs;
+
+            for (let tab of tabs) {
+                if (tab.classList.contains("selected"))
+                    return tab;
+            }
+        }
+
+        // Get tab ID
+        function getTabId(elements) {
+            const activeTab = getActiveTab(elements);
+            return tabNameToElementId[activeTab.innerText];
+        }
+
+        // Wait until opts loaded
+        async function waitForOpts() {
+            for (; ;) {
+                if (window.opts && Object.keys(window.opts).length) {
+                    return window.opts;
+                }
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+        }
+
+        // Detect whether the element has a horizontal scroll bar
+        function hasHorizontalScrollbar(element) {
+            return element.scrollWidth > element.clientWidth;
+        }
+
+        // Function for defining the "Ctrl", "Shift" and "Alt" keys
+        function isModifierKey(event, key) {
+            switch (key) {
+                case "Ctrl":
+                    return event.ctrlKey;
+                case "Shift":
+                    return event.shiftKey;
+                case "Alt":
+                    return event.altKey;
+                default:
+                    return false;
+            }
+        }
+
+        // Check if hotkey is valid
+        function isValidHotkey(value) {
+            const specialKeys = ["Ctrl", "Alt", "Shift", "Disable"];
+            return (
+                (typeof value === "string" &&
+                    value.length === 1 &&
+                    /[a-z]/i.test(value)) ||
+                specialKeys.includes(value)
+            );
+        }
+
+        // Normalize hotkey
+        function normalizeHotkey(hotkey) {
+            return hotkey.length === 1 ? "Key" + hotkey.toUpperCase() : hotkey;
+        }
+
+        // Format hotkey for display
+        function formatHotkeyForDisplay(hotkey) {
+            return hotkey.startsWith("Key") ? hotkey.slice(3) : hotkey;
+        }
+
+        // Create hotkey configuration with the provided options
+        function createHotkeyConfig(defaultHotkeysConfig, hotkeysConfigOpts) {
+            const result = {}; // Resulting hotkey configuration
+            const usedKeys = new Set(); // Set of used hotkeys
+
+            // Iterate through defaultHotkeysConfig keys
+            for (const key in defaultHotkeysConfig) {
+                const userValue = hotkeysConfigOpts[key]; // User-provided hotkey value
+                const defaultValue = defaultHotkeysConfig[key]; // Default hotkey value
+
+                // Apply appropriate value for undefined, boolean, or object userValue
+                if (
+                    userValue === undefined ||
+                    typeof userValue === "boolean" ||
+                    typeof userValue === "object" ||
+                    userValue === "disable"
+                ) {
+                    result[key] =
+                        userValue === undefined ? defaultValue : userValue;
+                } else if (isValidHotkey(userValue)) {
+                    const normalizedUserValue = normalizeHotkey(userValue);
+
+                    // Check for conflicting hotkeys
+                    if (!usedKeys.has(normalizedUserValue)) {
+                        usedKeys.add(normalizedUserValue);
+                        result[key] = normalizedUserValue;
+                    } else {
+                        console.error(
+                            `Hotkey: ${formatHotkeyForDisplay(
+                                userValue
+                            )} for ${key} is repeated and conflicts with another hotkey. The default hotkey is used: ${formatHotkeyForDisplay(
+                                defaultValue
+                            )}`
+                        );
+                        result[key] = defaultValue;
+                    }
+                } else {
+                    console.error(
+                        `Hotkey: ${formatHotkeyForDisplay(
+                            userValue
+                        )} for ${key} is not valid. The default hotkey is used: ${formatHotkeyForDisplay(
+                            defaultValue
+                        )}`
+                    );
+                    result[key] = defaultValue;
+                }
+            }
+
+            return result;
+        }
+
+        // Disables functions in the config object based on the provided list of function names
+        function disableFunctions(config, disabledFunctions) {
+            // Bind the hasOwnProperty method to the functionMap object to avoid errors
+            const hasOwnProperty =
+                Object.prototype.hasOwnProperty.bind(functionMap);
+
+            // Loop through the disabledFunctions array and disable the corresponding functions in the config object
+            disabledFunctions.forEach(funcName => {
+                if (hasOwnProperty(funcName)) {
+                    const key = functionMap[funcName];
+                    config[key] = "disable";
+                }
+            });
+
+            // Return the updated config object
+            return config;
+        }
+
+        /**
+         * The restoreImgRedMask function displays a red mask around an image to indicate the aspect ratio.
+         * If the image display property is set to 'none', the mask breaks. To fix this, the function
+         * temporarily sets the display property to 'block' and then hides the mask again after 300 milliseconds
+         * to avoid breaking the canvas. Additionally, the function adjusts the mask to work correctly on
+         * very long images.
+         */
+        function restoreImgRedMask(elements) {
+            const mainTabId = getTabId(elements);
+
+            if (!mainTabId) return;
+
+            const mainTab = gradioApp().querySelector(mainTabId);
+            const img = mainTab.querySelector("img");
+            const imageARPreview = gradioApp().querySelector("#imageARPreview");
+
+            if (!img || !imageARPreview) return;
+
+            imageARPreview.style.transform = "";
+            if (parseFloat(mainTab.style.width) > 865) {
+                const transformString = mainTab.style.transform;
+                const scaleMatch = transformString.match(
+                    /scale\(([-+]?[0-9]*\.?[0-9]+)\)/
+                );
+                let zoom = 1; // default zoom
+
+                if (scaleMatch && scaleMatch[1]) {
+                    zoom = Number(scaleMatch[1]);
+                }
+
+                imageARPreview.style.transformOrigin = "0 0";
+                imageARPreview.style.transform = `scale(${zoom})`;
+            }
+
+            if (img.style.display !== "none") return;
+
+            img.style.display = "block";
+
+            setTimeout(() => {
+                img.style.display = "none";
+            }, 400);
+        }
+
+        const hotkeysConfigOpts = await waitForOpts();
+
+        // Default config
+        const defaultHotkeysConfig = {
+            canvas_hotkey_zoom: "Alt",
+            canvas_hotkey_adjust: "Ctrl",
+            canvas_hotkey_reset: "KeyR",
+            canvas_hotkey_fullscreen: "KeyS",
+            canvas_hotkey_move: "KeyF",
+            canvas_hotkey_overlap: "KeyO",
+            canvas_hotkey_shrink_brush: "KeyQ",
+            canvas_hotkey_grow_brush: "KeyW",
+            canvas_disabled_functions: [],
+            canvas_show_tooltip: true,
+            canvas_auto_expand: true,
+            canvas_blur_prompt: false,
+        };
+
+        const functionMap = {
+            "Zoom": "canvas_hotkey_zoom",
+            "Adjust brush size": "canvas_hotkey_adjust",
+            "Hotkey shrink brush": "canvas_hotkey_shrink_brush",
+            "Hotkey enlarge brush": "canvas_hotkey_grow_brush",
+            "Moving canvas": "canvas_hotkey_move",
+            "Fullscreen": "canvas_hotkey_fullscreen",
+            "Reset Zoom": "canvas_hotkey_reset",
+            "Overlap": "canvas_hotkey_overlap"
+        };
+
+        // Loading the configuration from opts
+        const preHotkeysConfig = createHotkeyConfig(
+            defaultHotkeysConfig,
+            hotkeysConfigOpts
+        );
+
+        // Disable functions that are not needed by the user
+        const hotkeysConfig = disableFunctions(
+            preHotkeysConfig,
+            preHotkeysConfig.canvas_disabled_functions
+        );
+
+        let isMoving = false;
+        let mouseX, mouseY;
+        let activeElement;
+
+        const elements = Object.fromEntries(
+            Object.keys(elementIDs).map(id => [
+                id,
+                gradioApp().querySelector(elementIDs[id])
+            ])
+        );
+        const elemData = {};
+
+        // Apply functionality to the range inputs. Restore redmask and correct for long images.
+        const rangeInputs = elements.rangeGroup ?
+            Array.from(elements.rangeGroup.querySelectorAll("input")) :
+            [
+                gradioApp().querySelector("#img2img_width input[type='range']"),
+                gradioApp().querySelector("#img2img_height input[type='range']")
+            ];
+
+        for (const input of rangeInputs) {
+            input?.addEventListener("input", () => restoreImgRedMask(elements));
+        }
+
+        function applyZoomAndPan(elemId, isExtension = true) {
+            const targetElement = gradioApp().querySelector(elemId);
+
+            if (!targetElement) {
+                console.log("Element not found");
+                return;
+            }
+
+            targetElement.style.transformOrigin = "0 0";
+
+            elemData[elemId] = {
+                zoom: 1,
+                panX: 0,
+                panY: 0
+            };
+            let fullScreenMode = false;
+
+            // Create tooltip
+            function createTooltip() {
+                const toolTipElement =
+                    targetElement.querySelector(".image-container");
+                const tooltip = document.createElement("div");
+                tooltip.className = "canvas-tooltip";
+
+                // Creating an item of information
+                const info = document.createElement("i");
+                info.className = "canvas-tooltip-info";
+                info.textContent = "";
+
+                // Create a container for the contents of the tooltip
+                const tooltipContent = document.createElement("div");
+                tooltipContent.className = "canvas-tooltip-content";
+
+                // Define an array with hotkey information and their actions
+                const hotkeysInfo = [
+                    {
+                        configKey: "canvas_hotkey_zoom",
+                        action: "Zoom canvas",
+                        keySuffix: " + wheel"
+                    },
+                    {
+                        configKey: "canvas_hotkey_adjust",
+                        action: "Adjust brush size",
+                        keySuffix: " + wheel"
+                    },
+                    { configKey: "canvas_hotkey_reset", action: "Reset zoom" },
+                    {
+                        configKey: "canvas_hotkey_fullscreen",
+                        action: "Fullscreen mode"
+                    },
+                    { configKey: "canvas_hotkey_move", action: "Move canvas" },
+                    { configKey: "canvas_hotkey_overlap", action: "Overlap" }
+                ];
+
+                // Create hotkeys array with disabled property based on the config values
+                const hotkeys = hotkeysInfo.map(info => {
+                    const configValue = hotkeysConfig[info.configKey];
+                    const key = info.keySuffix ?
+                        `${configValue}${info.keySuffix}` :
+                        configValue.charAt(configValue.length - 1);
+                    return {
+                        key,
+                        action: info.action,
+                        disabled: configValue === "disable"
+                    };
+                });
+
+                for (const hotkey of hotkeys) {
+                    if (hotkey.disabled) {
+                        continue;
+                    }
+
+                    const p = document.createElement("p");
+                    p.innerHTML = `<b>${hotkey.key}</b> - ${hotkey.action}`;
+                    tooltipContent.appendChild(p);
+                }
+
+                // Add information and content elements to the tooltip element
+                tooltip.appendChild(info);
+                tooltip.appendChild(tooltipContent);
+
+                // Add a hint element to the target element
+                toolTipElement.appendChild(tooltip);
+            }
+
+            //Show tool tip if setting enable
+            if (hotkeysConfig.canvas_show_tooltip) {
+                createTooltip();
+            }
+
+            // In the course of research, it was found that the tag img is very harmful when zooming and creates white canvases. This hack allows you to almost never think about this problem, it has no effect on webui.
+            function fixCanvas() {
+                const activeTab = getActiveTab(elements).textContent.trim();
+
+                if (activeTab !== "img2img") {
+                    const img = targetElement.querySelector(`${elemId} img`);
+
+                    if (img && img.style.display !== "none") {
+                        img.style.display = "none";
+                        img.style.visibility = "hidden";
+                    }
+                }
+            }
+
+            // Reset the zoom level and pan position of the target element to their initial values
+            function resetZoom() {
+                elemData[elemId] = {
+                    zoomLevel: 1,
+                    panX: 0,
+                    panY: 0
+                };
+
+                if (isExtension) {
+                    targetElement.style.overflow = "hidden";
+                }
+
+                targetElement.isZoomed = false;
+
+                fixCanvas();
+                targetElement.style.transform = `scale(${elemData[elemId].zoomLevel}) translate(${elemData[elemId].panX}px, ${elemData[elemId].panY}px)`;
+
+                const canvas = gradioApp().querySelector(
+                    `${elemId} canvas[key="interface"]`
+                );
+
+                toggleOverlap("off");
+                fullScreenMode = false;
+
+                const closeBtn = targetElement.querySelector("button[aria-label='Remove Image']");
+                if (closeBtn) {
+                    closeBtn.addEventListener("click", resetZoom);
+                }
+
+                if (canvas && isExtension) {
+                    const parentElement = targetElement.closest('[id^="component-"]');
+                    if (
+                        canvas &&
+                        parseFloat(canvas.style.width) > parentElement.offsetWidth &&
+                        parseFloat(targetElement.style.width) > parentElement.offsetWidth
+                    ) {
+                        fitToElement();
+                        return;
+                    }
+
+                }
+
+                if (
+                    canvas &&
+                    !isExtension &&
+                    parseFloat(canvas.style.width) > 865 &&
+                    parseFloat(targetElement.style.width) > 865
+                ) {
+                    fitToElement();
+                    return;
+                }
+
+                targetElement.style.width = "";
+            }
+
+            // Toggle the zIndex of the target element between two values, allowing it to overlap or be overlapped by other elements
+            function toggleOverlap(forced = "") {
+                const zIndex1 = "0";
+                const zIndex2 = "998";
+
+                targetElement.style.zIndex =
+                    targetElement.style.zIndex !== zIndex2 ? zIndex2 : zIndex1;
+
+                if (forced === "off") {
+                    targetElement.style.zIndex = zIndex1;
+                } else if (forced === "on") {
+                    targetElement.style.zIndex = zIndex2;
+                }
+            }
+
+            // Adjust the brush size based on the deltaY value from a mouse wheel event
+            function adjustBrushSize(
+                elemId,
+                deltaY,
+                withoutValue = false,
+                percentage = 5
+            ) {
+                const input =
+                    gradioApp().querySelector(
+                        `${elemId} input[aria-label='Brush radius']`
+                    ) ||
+                    gradioApp().querySelector(
+                        `${elemId} button[aria-label="Use brush"]`
+                    );
+
+                if (input) {
+                    input.click();
+                    if (!withoutValue) {
+                        const maxValue =
+                            parseFloat(input.getAttribute("max")) || 100;
+                        const changeAmount = maxValue * (percentage / 100);
+                        const newValue =
+                            parseFloat(input.value) +
+                            (deltaY > 0 ? -changeAmount : changeAmount);
+                        input.value = Math.min(Math.max(newValue, 0), maxValue);
+                        input.dispatchEvent(new Event("change"));
+                    }
+                }
+            }
+
+            // Reset zoom when uploading a new image
+            const fileInput = gradioApp().querySelector(
+                `${elemId} input[type="file"][accept="image/*"].svelte-116rqfv`
+            );
+            fileInput.addEventListener("click", resetZoom);
+
+            // Update the zoom level and pan position of the target element based on the values of the zoomLevel, panX and panY variables
+            function updateZoom(newZoomLevel, mouseX, mouseY) {
+                newZoomLevel = Math.max(0.1, Math.min(newZoomLevel, 15));
+
+                elemData[elemId].panX +=
+                    mouseX - (mouseX * newZoomLevel) / elemData[elemId].zoomLevel;
+                elemData[elemId].panY +=
+                    mouseY - (mouseY * newZoomLevel) / elemData[elemId].zoomLevel;
+
+                targetElement.style.transformOrigin = "0 0";
+                targetElement.style.transform = `translate(${elemData[elemId].panX}px, ${elemData[elemId].panY}px) scale(${newZoomLevel})`;
+
+                toggleOverlap("on");
+                if (isExtension) {
+                    targetElement.style.overflow = "visible";
+                }
+
+                return newZoomLevel;
+            }
+
+            // Change the zoom level based on user interaction
+            function changeZoomLevel(operation, e) {
+                if (isModifierKey(e, hotkeysConfig.canvas_hotkey_zoom)) {
+                    e.preventDefault();
+
+                    let zoomPosX, zoomPosY;
+                    let delta = 0.2;
+                    if (elemData[elemId].zoomLevel > 7) {
+                        delta = 0.9;
+                    } else if (elemData[elemId].zoomLevel > 2) {
+                        delta = 0.6;
+                    }
+
+                    zoomPosX = e.clientX;
+                    zoomPosY = e.clientY;
+
+                    fullScreenMode = false;
+                    elemData[elemId].zoomLevel = updateZoom(
+                        elemData[elemId].zoomLevel +
+                        (operation === "+" ? delta : -delta),
+                        zoomPosX - targetElement.getBoundingClientRect().left,
+                        zoomPosY - targetElement.getBoundingClientRect().top
+                    );
+
+                    targetElement.isZoomed = true;
+                }
+            }
+
+            /**
+             * This function fits the target element to the screen by calculating
+             * the required scale and offsets. It also updates the global variables
+             * zoomLevel, panX, and panY to reflect the new state.
+             */
+
+            function fitToElement() {
+                //Reset Zoom
+                targetElement.style.transform = `translate(${0}px, ${0}px) scale(${1})`;
+
+                let parentElement;
+
+                if (isExtension) {
+                    parentElement = targetElement.closest('[id^="component-"]');
+                } else {
+                    parentElement = targetElement.parentElement;
+                }
+
+
+                // Get element and screen dimensions
+                const elementWidth = targetElement.offsetWidth;
+                const elementHeight = targetElement.offsetHeight;
+
+                const screenWidth = parentElement.clientWidth;
+                const screenHeight = parentElement.clientHeight;
+
+                // Get element's coordinates relative to the parent element
+                const elementRect = targetElement.getBoundingClientRect();
+                const parentRect = parentElement.getBoundingClientRect();
+                const elementX = elementRect.x - parentRect.x;
+
+                // Calculate scale and offsets
+                const scaleX = screenWidth / elementWidth;
+                const scaleY = screenHeight / elementHeight;
+                const scale = Math.min(scaleX, scaleY);
+
+                const transformOrigin =
+                    window.getComputedStyle(targetElement).transformOrigin;
+                const [originX, originY] = transformOrigin.split(" ");
+                const originXValue = parseFloat(originX);
+                const originYValue = parseFloat(originY);
+
+                const offsetX =
+                    (screenWidth - elementWidth * scale) / 2 -
+                    originXValue * (1 - scale);
+                const offsetY =
+                    (screenHeight - elementHeight * scale) / 2.5 -
+                    originYValue * (1 - scale);
+
+                // Apply scale and offsets to the element
+                targetElement.style.transform = `translate(${offsetX}px, ${offsetY}px) scale(${scale})`;
+
+                // Update global variables
+                elemData[elemId].zoomLevel = scale;
+                elemData[elemId].panX = offsetX;
+                elemData[elemId].panY = offsetY;
+
+                fullScreenMode = false;
+                toggleOverlap("off");
+            }
+
+            /**
+             * This function fits the target element to the screen by calculating
+             * the required scale and offsets. It also updates the global variables
+             * zoomLevel, panX, and panY to reflect the new state.
+             */
+
+            // Fullscreen mode
+            function fitToScreen() {
+                const canvas = gradioApp().querySelector(
+                    `${elemId} canvas[key="interface"]`
+                );
+
+                if (!canvas) return;
+
+                if (canvas.offsetWidth > 862 || isExtension) {
+                    targetElement.style.width = (canvas.offsetWidth + 2) + "px";
+                }
+
+                if (isExtension) {
+                    targetElement.style.overflow = "visible";
+                }
+
+                if (fullScreenMode) {
+                    resetZoom();
+                    fullScreenMode = false;
+                    return;
+                }
+
+                //Reset Zoom
+                targetElement.style.transform = `translate(${0}px, ${0}px) scale(${1})`;
+
+                // Get scrollbar width to right-align the image
+                const scrollbarWidth =
+                    window.innerWidth - document.documentElement.clientWidth;
+
+                // Get element and screen dimensions
+                const elementWidth = targetElement.offsetWidth;
+                const elementHeight = targetElement.offsetHeight;
+                const screenWidth = window.innerWidth - scrollbarWidth;
+                const screenHeight = window.innerHeight;
+
+                // Get element's coordinates relative to the page
+                const elementRect = targetElement.getBoundingClientRect();
+                const elementY = elementRect.y;
+                const elementX = elementRect.x;
+
+                // Calculate scale and offsets
+                const scaleX = screenWidth / elementWidth;
+                const scaleY = screenHeight / elementHeight;
+                const scale = Math.min(scaleX, scaleY);
+
+                // Get the current transformOrigin
+                const computedStyle = window.getComputedStyle(targetElement);
+                const transformOrigin = computedStyle.transformOrigin;
+                const [originX, originY] = transformOrigin.split(" ");
+                const originXValue = parseFloat(originX);
+                const originYValue = parseFloat(originY);
+
+                // Calculate offsets with respect to the transformOrigin
+                const offsetX =
+                    (screenWidth - elementWidth * scale) / 2 -
+                    elementX -
+                    originXValue * (1 - scale);
+                const offsetY =
+                    (screenHeight - elementHeight * scale) / 2 -
+                    elementY -
+                    originYValue * (1 - scale);
+
+                // Apply scale and offsets to the element
+                targetElement.style.transform = `translate(${offsetX}px, ${offsetY}px) scale(${scale})`;
+
+                // Update global variables
+                elemData[elemId].zoomLevel = scale;
+                elemData[elemId].panX = offsetX;
+                elemData[elemId].panY = offsetY;
+
+                fullScreenMode = true;
+                toggleOverlap("on");
+            }
+
+            // Handle keydown events
+            function handleKeyDown(event) {
+                // Disable key locks to make pasting from the buffer work correctly
+                if ((event.ctrlKey && event.code === 'KeyV') || (event.ctrlKey && event.code === 'KeyC') || event.code === "F5") {
+                    return;
+                }
+
+                // before activating shortcut, ensure user is not actively typing in an input field
+                if (!hotkeysConfig.canvas_blur_prompt) {
+                    if (event.target.nodeName === 'TEXTAREA' || event.target.nodeName === 'INPUT') {
+                        return;
+                    }
+                }
+
+
+                const hotkeyActions = {
+                    [hotkeysConfig.canvas_hotkey_reset]: resetZoom,
+                    [hotkeysConfig.canvas_hotkey_overlap]: toggleOverlap,
+                    [hotkeysConfig.canvas_hotkey_fullscreen]: fitToScreen,
+                    [hotkeysConfig.canvas_hotkey_shrink_brush]: () => adjustBrushSize(elemId, 10),
+                    [hotkeysConfig.canvas_hotkey_grow_brush]: () => adjustBrushSize(elemId, -10)
+                };
+
+                const action = hotkeyActions[event.code];
+                if (action) {
+                    event.preventDefault();
+                    action(event);
+                }
+
+                if (
+                    isModifierKey(event, hotkeysConfig.canvas_hotkey_zoom) ||
+                    isModifierKey(event, hotkeysConfig.canvas_hotkey_adjust)
+                ) {
+                    event.preventDefault();
+                }
+            }
+
+            // Get Mouse position
+            function getMousePosition(e) {
+                mouseX = e.offsetX;
+                mouseY = e.offsetY;
+            }
+
+            // Simulation of the function to put a long image into the screen.
+            // We detect if an image has a scroll bar or not, make a fullscreen to reveal the image, then reduce it to fit into the element.
+            // We hide the image and show it to the user when it is ready.
+
+            targetElement.isExpanded = false;
+            function autoExpand() {
+                const canvas = document.querySelector(`${elemId} canvas[key="interface"]`);
+                if (canvas) {
+                    if (hasHorizontalScrollbar(targetElement) && targetElement.isExpanded === false) {
+                        targetElement.style.visibility = "hidden";
+                        setTimeout(() => {
+                            fitToScreen();
+                            resetZoom();
+                            targetElement.style.visibility = "visible";
+                            targetElement.isExpanded = true;
+                        }, 10);
+                    }
+                }
+            }
+
+            targetElement.addEventListener("mousemove", getMousePosition);
+
+            //observers
+            // Creating an observer with a callback function to handle DOM changes
+            const observer = new MutationObserver((mutationsList, observer) => {
+                for (let mutation of mutationsList) {
+                    // If the style attribute of the canvas has changed, by observation it happens only when the picture changes
+                    if (mutation.type === 'attributes' && mutation.attributeName === 'style' &&
+                        mutation.target.tagName.toLowerCase() === 'canvas') {
+                        targetElement.isExpanded = false;
+                        setTimeout(resetZoom, 10);
+                    }
+                }
+            });
+
+            // Apply auto expand if enabled
+            if (hotkeysConfig.canvas_auto_expand) {
+                targetElement.addEventListener("mousemove", autoExpand);
+                // Set up an observer to track attribute changes
+                observer.observe(targetElement, { attributes: true, childList: true, subtree: true });
+            }
+
+            // Handle events only inside the targetElement
+            let isKeyDownHandlerAttached = false;
+
+            function handleMouseMove() {
+                if (!isKeyDownHandlerAttached) {
+                    document.addEventListener("keydown", handleKeyDown);
+                    isKeyDownHandlerAttached = true;
+
+                    activeElement = elemId;
+                }
+            }
+
+            function handleMouseLeave() {
+                if (isKeyDownHandlerAttached) {
+                    document.removeEventListener("keydown", handleKeyDown);
+                    isKeyDownHandlerAttached = false;
+
+                    activeElement = null;
+                }
+            }
+
+            // Add mouse event handlers
+            targetElement.addEventListener("mousemove", handleMouseMove);
+            targetElement.addEventListener("mouseleave", handleMouseLeave);
+
+            // Reset zoom when click on another tab
+            elements.img2imgTabs.addEventListener("click", resetZoom);
+            elements.img2imgTabs.addEventListener("click", () => {
+                // targetElement.style.width = "";
+                if (parseInt(targetElement.style.width) > 865) {
+                    setTimeout(fitToElement, 0);
+                }
+            });
+
+            targetElement.addEventListener("wheel", e => {
+                // change zoom level
+                const operation = e.deltaY > 0 ? "-" : "+";
+                changeZoomLevel(operation, e);
+
+                // Handle brush size adjustment with ctrl key pressed
+                if (isModifierKey(e, hotkeysConfig.canvas_hotkey_adjust)) {
+                    e.preventDefault();
+
+                    // Increase or decrease brush size based on scroll direction
+                    adjustBrushSize(elemId, e.deltaY);
+                }
+            });
+
+            // Handle the move event for pan functionality. Updates the panX and panY variables and applies the new transform to the target element.
+            function handleMoveKeyDown(e) {
+
+                // Disable key locks to make pasting from the buffer work correctly
+                if ((e.ctrlKey && e.code === 'KeyV') || (e.ctrlKey && event.code === 'KeyC') || e.code === "F5") {
+                    return;
+                }
+
+                // before activating shortcut, ensure user is not actively typing in an input field
+                if (!hotkeysConfig.canvas_blur_prompt) {
+                    if (e.target.nodeName === 'TEXTAREA' || e.target.nodeName === 'INPUT') {
+                        return;
+                    }
+                }
+
+
+                if (e.code === hotkeysConfig.canvas_hotkey_move) {
+                    if (!e.ctrlKey && !e.metaKey && isKeyDownHandlerAttached) {
+                        e.preventDefault();
+                        document.activeElement.blur();
+                        isMoving = true;
+                    }
+                }
+            }
+
+            function handleMoveKeyUp(e) {
+                if (e.code === hotkeysConfig.canvas_hotkey_move) {
+                    isMoving = false;
+                }
+            }
+
+            document.addEventListener("keydown", handleMoveKeyDown);
+            document.addEventListener("keyup", handleMoveKeyUp);
+
+            // Detect zoom level and update the pan speed.
+            function updatePanPosition(movementX, movementY) {
+                let panSpeed = 2;
+
+                if (elemData[elemId].zoomLevel > 8) {
+                    panSpeed = 3.5;
+                }
+
+                elemData[elemId].panX += movementX * panSpeed;
+                elemData[elemId].panY += movementY * panSpeed;
+
+                // Delayed redraw of an element
+                requestAnimationFrame(() => {
+                    targetElement.style.transform = `translate(${elemData[elemId].panX}px, ${elemData[elemId].panY}px) scale(${elemData[elemId].zoomLevel})`;
+                    toggleOverlap("on");
+                });
+            }
+
+            function handleMoveByKey(e) {
+                if (isMoving && elemId === activeElement) {
+                    updatePanPosition(e.movementX, e.movementY);
+                    targetElement.style.pointerEvents = "none";
+
+                    if (isExtension) {
+                        targetElement.style.overflow = "visible";
+                    }
+
+                } else {
+                    targetElement.style.pointerEvents = "auto";
+                }
+            }
+
+            // Prevents sticking to the mouse
+            window.onblur = function () {
+                isMoving = false;
+            };
+
+            // Checks for extension
+            function checkForOutBox() {
+                const parentElement = targetElement.closest('[id^="component-"]');
+                if (parentElement.offsetWidth < targetElement.offsetWidth && !targetElement.isExpanded) {
+                    resetZoom();
+                    targetElement.isExpanded = true;
+                }
+
+                if (parentElement.offsetWidth < targetElement.offsetWidth && elemData[elemId].zoomLevel == 1) {
+                    resetZoom();
+                }
+
+                if (parentElement.offsetWidth < targetElement.offsetWidth && targetElement.offsetWidth * elemData[elemId].zoomLevel > parentElement.offsetWidth && elemData[elemId].zoomLevel < 1 && !targetElement.isZoomed) {
+                    resetZoom();
+                }
+            }
+
+            if (isExtension) {
+                targetElement.addEventListener("mousemove", checkForOutBox);
+            }
+
+
+            window.addEventListener('resize', (e) => {
+                resetZoom();
+
+                if (isExtension) {
+                    targetElement.isExpanded = false;
+                    targetElement.isZoomed = false;
+                }
+            });
+
+            gradioApp().addEventListener("mousemove", handleMoveByKey);
+
+
+        }
+
+        applyZoomAndPan(elementIDs.sketch, false);
+        applyZoomAndPan(elementIDs.inpaint, false);
+        applyZoomAndPan(elementIDs.inpaintSketch, false);
+
+        // Make the function global so that other extensions can take advantage of this solution
+        const applyZoomAndPanIntegration = async (id, elementIDs) => {
+            const mainEl = document.querySelector(id);
+            if (id.toLocaleLowerCase() === "none") {
+                for (const elementID of elementIDs) {
+                    const el = await waitForElement(elementID);
+                    if (!el) break;
+                    applyZoomAndPan(elementID);
+                }
+                return;
+            }
+
+            if (!mainEl) return;
+            mainEl.addEventListener("click", async () => {
+                for (const elementID of elementIDs) {
+                    const el = await waitForElement(elementID);
+                    if (!el) break;
+                    applyZoomAndPan(elementID);
+                }
+            }, { once: true });
+        };
+
+        window.applyZoomAndPan = applyZoomAndPan; // Only 1 elements, argument elementID, for example applyZoomAndPan("#txt2img_controlnet_ControlNet_input_image")
+        window.applyZoomAndPanIntegration = applyZoomAndPanIntegration; // for any extension
+    });
+
+})();

extensions-builtin/canvas-zoom-and-pan/scripts/hotkey_config.py

@@ -0,0 +1,17 @@
+from modules import shared
+import gradio as gr
+
+shared.options_templates.update(shared.options_section(("canvas_hotkey", "Canvas Hotkeys", "ui"), {
+    "canvas_hotkey_zoom": shared.OptionInfo("Alt", "Zoom canvas", gr.Radio, {"choices": ["Shift","Ctrl", "Alt"]}).info("If you choose 'Shift' you cannot scroll horizontally, 'Alt' can cause a little trouble in firefox"),
+    "canvas_hotkey_adjust": shared.OptionInfo("Ctrl", "Adjust brush size", gr.Radio, {"choices": ["Shift","Ctrl", "Alt"]}).info("If you choose 'Shift' you cannot scroll horizontally, 'Alt' can cause a little trouble in firefox"),
+    "canvas_hotkey_shrink_brush": shared.OptionInfo("Q", "Shrink the brush size"),
+    "canvas_hotkey_grow_brush": shared.OptionInfo("W", "Enlarge the brush size"),
+    "canvas_hotkey_move": shared.OptionInfo("F", "Moving the canvas").info("To work correctly in firefox, turn off 'Automatically search the page text when typing' in the browser settings"),
+    "canvas_hotkey_fullscreen": shared.OptionInfo("S", "Fullscreen Mode, maximizes the picture so that it fits into the screen and stretches it to its full width "),
+    "canvas_hotkey_reset": shared.OptionInfo("R", "Reset zoom and canvas position"),
+    "canvas_hotkey_overlap": shared.OptionInfo("O", "Toggle overlap").info("Technical button, neededs for testing"),
+    "canvas_show_tooltip": shared.OptionInfo(True, "Enable tooltip on the canvas"),
+    "canvas_auto_expand": shared.OptionInfo(True, "Automatically expands an image that does not fit completely in the canvas area, similar to manually pressing the S and R buttons"),
+    "canvas_blur_prompt": shared.OptionInfo(False, "Take the focus off the prompt when working with a canvas"),
+    "canvas_disabled_functions": shared.OptionInfo(["Overlap"], "Disable function that you don't use", gr.CheckboxGroup, {"choices": ["Zoom","Adjust brush size","Hotkey enlarge brush","Hotkey shrink brush","Moving canvas","Fullscreen","Reset Zoom","Overlap"]}),
+}))

extensions-builtin/canvas-zoom-and-pan/style.css

@@ -0,0 +1,71 @@
+.canvas-tooltip-info {
+  position: absolute;
+  top: 10px;
+  left: 10px;
+  cursor: help;
+  background-color: rgba(0, 0, 0, 0.3);
+  width: 20px;
+  height: 20px;
+  border-radius: 50%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex-direction: column;
+
+  z-index: 100;
+}
+
+.canvas-tooltip-info::after {
+  content: '';
+  display: block;
+  width: 2px;
+  height: 7px;
+  background-color: white;
+  margin-top: 2px;
+}
+
+.canvas-tooltip-info::before {
+  content: '';
+  display: block;
+  width: 2px;
+  height: 2px;
+  background-color: white;
+}
+
+.canvas-tooltip-content {
+  display: none;
+  background-color: #f9f9f9;
+  color: #333;
+  border: 1px solid #ddd;
+  padding: 15px;
+  position: absolute;
+  top: 40px;
+  left: 10px;
+  width: 250px;
+  font-size: 16px;
+  opacity: 0;
+  border-radius: 8px;
+  box-shadow: 0px 8px 16px 0px rgba(0, 0, 0, 0.2);
+
+  z-index: 100;
+}
+
+.canvas-tooltip:hover .canvas-tooltip-content {
+  display: block;
+  animation: fadeIn 0.5s;
+  opacity: 1;
+}
+
+@keyframes fadeIn {
+  from {
+    opacity: 0;
+  }
+
+  to {
+    opacity: 1;
+  }
+}
+
+.styler {
+  overflow: inherit !important;
+}

extensions-builtin/extra-options-section/scripts/extra_options_section.py

@@ -0,0 +1,124 @@
+from modules import scripts, shared, ui_components, ui_settings, infotext_utils
+from modules.ui_components import FormColumn
+
+import gradio as gr
+import math
+
+
+class ExtraOptionsSection(scripts.Script):
+    section = "extra_options"
+
+    def __init__(self):
+        self.comps = None
+        self.setting_names = None
+
+    def title(self):
+        return "Extra options"
+
+    def show(self, is_img2img):
+        return scripts.AlwaysVisible
+
+    def ui(self, is_img2img):
+        self.comps = []
+        self.setting_names = []
+        self.infotext_fields = []
+        extra_options = (
+            shared.opts.extra_options_img2img
+            if is_img2img
+            else shared.opts.extra_options_txt2img
+        )
+        elem_id_tabname = "extra_options_" + ("img2img" if is_img2img else "txt2img")
+
+        mapping = {k: v for v, k in infotext_utils.infotext_to_setting_name_mapping}
+
+        with gr.Blocks() as interface:
+            with (
+                gr.Accordion("Options", open=False, elem_id=elem_id_tabname)
+                if shared.opts.extra_options_accordion and extra_options
+                else gr.Group(elem_id=elem_id_tabname)
+            ):
+
+                row_count = math.ceil(
+                    len(extra_options) / shared.opts.extra_options_cols
+                )
+
+                for row in range(row_count):
+                    with gr.Row():
+                        for col in range(shared.opts.extra_options_cols):
+                            index = row * shared.opts.extra_options_cols + col
+                            if index >= len(extra_options):
+                                break
+
+                            setting_name = extra_options[index]
+
+                            with FormColumn():
+                                comp = ui_settings.create_setting_component(
+                                    setting_name
+                                )
+
+                            self.comps.append(comp)
+                            self.setting_names.append(setting_name)
+
+                            setting_infotext_name = mapping.get(setting_name)
+                            if setting_infotext_name is not None:
+                                self.infotext_fields.append(
+                                    (comp, setting_infotext_name)
+                                )
+
+        def get_settings_values():
+            res = [ui_settings.get_value_for_setting(key) for key in self.setting_names]
+            return res[0] if len(res) == 1 else res
+
+        interface.load(
+            fn=get_settings_values,
+            inputs=[],
+            outputs=self.comps,
+            queue=False,
+            show_progress=False,
+        )
+
+        return self.comps
+
+    def before_process(self, p, *args):
+        for name, value in zip(self.setting_names, args):
+            if name not in p.override_settings:
+                p.override_settings[name] = value
+
+
+shared.options_templates.update(
+    shared.options_section(
+        ("settings_in_ui", "Settings in UI", "ui"),
+        {
+            "settings_in_ui": shared.OptionHTML("This page allows you to add some settings to the main interface of txt2img and img2img tabs."),
+            "extra_options_txt2img": shared.OptionInfo(
+                [],
+                "Settings for txt2img",
+                ui_components.DropdownMulti,
+                lambda: {"choices": list(shared.opts.data_labels.keys())},
+            )
+            .js("info", "settingsHintsShowQuicksettings")
+            .info("setting entries that also appear in txt2img interfaces")
+            .needs_reload_ui(),
+            "extra_options_img2img": shared.OptionInfo(
+                [],
+                "Settings for img2img",
+                ui_components.DropdownMulti,
+                lambda: {"choices": list(shared.opts.data_labels.keys())},
+            )
+            .js("info", "settingsHintsShowQuicksettings")
+            .info("setting entries that also appear in img2img interfaces")
+            .needs_reload_ui(),
+            "extra_options_cols": shared.OptionInfo(
+                1,
+                "Number of columns for added settings",
+                gr.Slider,
+                {"step": 1, "minimum": 1, "maximum": 20},
+            )
+            .info("displayed amount will depend on the actual browser window width")
+            .needs_reload_ui(),
+            "extra_options_accordion": shared.OptionInfo(
+                False, "Place added settings into an accordion"
+            ).needs_reload_ui(),
+        },
+    )
+)

extensions-builtin/forge_legacy_preprocessors/.gitignore

@@ -0,0 +1,185 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea
+*.pt
+*.pth
+*.ckpt
+*.bin
+*.safetensors
+
+# Editor setting metadata
+.idea/
+.vscode/
+detected_maps/
+annotator/downloads/
+
+# test results and expectations
+web_tests/results/
+web_tests/expectations/
+tests/web_api/full_coverage/results/
+tests/web_api/full_coverage/expectations/
+
+*_diff.png
+
+# Presets
+presets/
+
+# Ignore existing dir of hand refiner if exists.
+annotator/hand_refiner_portable

extensions-builtin/forge_legacy_preprocessors/LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://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 <https://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
+<https://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
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

extensions-builtin/forge_legacy_preprocessors/annotator/anime_face_segment/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Miaomiao Li
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

extensions-builtin/forge_legacy_preprocessors/annotator/anime_face_segment/__init__.py

@@ -0,0 +1,186 @@
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from PIL import Image
+import fnmatch
+import cv2
+
+import sys
+
+import numpy as np
+from modules import devices
+from einops import rearrange
+from annotator.annotator_path import models_path
+
+import torchvision
+from torchvision.models import MobileNet_V2_Weights
+from torchvision import transforms
+
+COLOR_BACKGROUND = (255, 255, 0)
+COLOR_HAIR = (0, 0, 255)
+COLOR_EYE = (255, 0, 0)
+COLOR_MOUTH = (255, 255, 255)
+COLOR_FACE = (0, 255, 0)
+COLOR_SKIN = (0, 255, 255)
+COLOR_CLOTHES = (255, 0, 255)
+PALETTE = [
+    COLOR_BACKGROUND,
+    COLOR_HAIR,
+    COLOR_EYE,
+    COLOR_MOUTH,
+    COLOR_FACE,
+    COLOR_SKIN,
+    COLOR_CLOTHES,
+]
+
+
+class UNet(nn.Module):
+    def __init__(self):
+        super(UNet, self).__init__()
+        self.NUM_SEG_CLASSES = 7  # Background, hair, face, eye, mouth, skin, clothes
+
+        mobilenet_v2 = torchvision.models.mobilenet_v2(
+            weights=MobileNet_V2_Weights.IMAGENET1K_V1
+        )
+        mob_blocks = mobilenet_v2.features
+
+        # Encoder
+        self.en_block0 = nn.Sequential(  # in_ch=3 out_ch=16
+            mob_blocks[0], mob_blocks[1]
+        )
+        self.en_block1 = nn.Sequential(  # in_ch=16 out_ch=24
+            mob_blocks[2],
+            mob_blocks[3],
+        )
+        self.en_block2 = nn.Sequential(  # in_ch=24 out_ch=32
+            mob_blocks[4],
+            mob_blocks[5],
+            mob_blocks[6],
+        )
+        self.en_block3 = nn.Sequential(  # in_ch=32 out_ch=96
+            mob_blocks[7],
+            mob_blocks[8],
+            mob_blocks[9],
+            mob_blocks[10],
+            mob_blocks[11],
+            mob_blocks[12],
+            mob_blocks[13],
+        )
+        self.en_block4 = nn.Sequential(  # in_ch=96 out_ch=160
+            mob_blocks[14],
+            mob_blocks[15],
+            mob_blocks[16],
+        )
+
+        # Decoder
+        self.de_block4 = nn.Sequential(  # in_ch=160 out_ch=96
+            nn.UpsamplingNearest2d(scale_factor=2),
+            nn.Conv2d(160, 96, kernel_size=3, padding=1),
+            nn.InstanceNorm2d(96),
+            nn.LeakyReLU(0.1),
+            nn.Dropout(p=0.2),
+        )
+        self.de_block3 = nn.Sequential(  # in_ch=96x2 out_ch=32
+            nn.UpsamplingNearest2d(scale_factor=2),
+            nn.Conv2d(96 * 2, 32, kernel_size=3, padding=1),
+            nn.InstanceNorm2d(32),
+            nn.LeakyReLU(0.1),
+            nn.Dropout(p=0.2),
+        )
+        self.de_block2 = nn.Sequential(  # in_ch=32x2 out_ch=24
+            nn.UpsamplingNearest2d(scale_factor=2),
+            nn.Conv2d(32 * 2, 24, kernel_size=3, padding=1),
+            nn.InstanceNorm2d(24),
+            nn.LeakyReLU(0.1),
+            nn.Dropout(p=0.2),
+        )
+        self.de_block1 = nn.Sequential(  # in_ch=24x2 out_ch=16
+            nn.UpsamplingNearest2d(scale_factor=2),
+            nn.Conv2d(24 * 2, 16, kernel_size=3, padding=1),
+            nn.InstanceNorm2d(16),
+            nn.LeakyReLU(0.1),
+            nn.Dropout(p=0.2),
+        )
+
+        self.de_block0 = nn.Sequential(  # in_ch=16x2 out_ch=7
+            nn.UpsamplingNearest2d(scale_factor=2),
+            nn.Conv2d(16 * 2, self.NUM_SEG_CLASSES, kernel_size=3, padding=1),
+            nn.Softmax2d(),
+        )
+
+    def forward(self, x):
+        e0 = self.en_block0(x)
+        e1 = self.en_block1(e0)
+        e2 = self.en_block2(e1)
+        e3 = self.en_block3(e2)
+        e4 = self.en_block4(e3)
+
+        d4 = self.de_block4(e4)
+        d4 = F.interpolate(d4, size=e3.size()[2:], mode="bilinear", align_corners=True)
+        c4 = torch.cat((d4, e3), 1)
+
+        d3 = self.de_block3(c4)
+        d3 = F.interpolate(d3, size=e2.size()[2:], mode="bilinear", align_corners=True)
+        c3 = torch.cat((d3, e2), 1)
+
+        d2 = self.de_block2(c3)
+        d2 = F.interpolate(d2, size=e1.size()[2:], mode="bilinear", align_corners=True)
+        c2 = torch.cat((d2, e1), 1)
+
+        d1 = self.de_block1(c2)
+        d1 = F.interpolate(d1, size=e0.size()[2:], mode="bilinear", align_corners=True)
+        c1 = torch.cat((d1, e0), 1)
+        y = self.de_block0(c1)
+
+        return y
+
+
+class AnimeFaceSegment:
+    model_dir = os.path.join(models_path, "anime_face_segment")
+
+    def __init__(self):
+        self.model = None
+        self.device = devices.get_device_for("controlnet")
+
+    def load_model(self):
+        remote_model_path = "https://huggingface.co/bdsqlsz/qinglong_controlnet-lllite/resolve/main/Annotators/UNet.pth"
+        modelpath = os.path.join(self.model_dir, "UNet.pth")
+        if not os.path.exists(modelpath):
+            from modules.modelloader import load_file_from_url
+
+            load_file_from_url(remote_model_path, model_dir=self.model_dir)
+        net = UNet()
+        ckpt = torch.load(modelpath, map_location=self.device)
+        for key in list(ckpt.keys()):
+            if "module." in key:
+                ckpt[key.replace("module.", "")] = ckpt[key]
+                del ckpt[key]
+        net.load_state_dict(ckpt)
+        net.eval()
+        self.model = net.to(self.device)
+
+    def unload_model(self):
+        if self.model is not None:
+            self.model.cpu()
+
+    def __call__(self, input_image):
+        if self.model is None:
+            self.load_model()
+        self.model.to(self.device)
+        transform = transforms.Compose(
+            [
+                transforms.Resize(
+                    512, interpolation=transforms.InterpolationMode.BICUBIC
+                ),
+                transforms.ToTensor(),
+            ]
+        )
+        img = Image.fromarray(input_image)
+        with torch.no_grad():
+            img = transform(img).unsqueeze(dim=0).to(self.device)
+            seg = self.model(img).squeeze(dim=0)
+            seg = seg.cpu().detach().numpy()
+            img = rearrange(seg, "h w c -> w c h")
+            img = [[PALETTE[np.argmax(val)] for val in buf] for buf in img]
+            return np.array(img).astype(np.uint8)

extensions-builtin/forge_legacy_preprocessors/annotator/annotator_path.py

@@ -0,0 +1,17 @@
+from modules_forge.shared import preprocessor_dir
+import os
+
+try:
+    from lib_controlnet.logging import logger
+
+    print = logger.info
+except ImportError:
+    pass
+
+models_path = preprocessor_dir
+clip_vision_path = os.path.join(preprocessor_dir, "clip_vision")
+
+os.makedirs(models_path, exist_ok=True)
+os.makedirs(clip_vision_path, exist_ok=True)
+
+print(f"Preprocessor location: {models_path}")

extensions-builtin/forge_legacy_preprocessors/annotator/binary/__init__.py

@@ -0,0 +1,16 @@
+import cv2
+
+
+def apply_binary(img, bin_threshold):
+    img_gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
+
+    if bin_threshold == 0 or bin_threshold == 255:
+        # Otsu's threshold
+        otsu_threshold, img_bin = cv2.threshold(
+            img_gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU
+        )
+        print("Otsu threshold:", otsu_threshold)
+    else:
+        _, img_bin = cv2.threshold(img_gray, bin_threshold, 255, cv2.THRESH_BINARY_INV)
+
+    return cv2.cvtColor(img_bin, cv2.COLOR_GRAY2RGB)

extensions-builtin/forge_legacy_preprocessors/annotator/canny/__init__.py

@@ -0,0 +1,5 @@
+import cv2
+
+
+def apply_canny(img, low_threshold, high_threshold):
+    return cv2.Canny(img, low_threshold, high_threshold)

extensions-builtin/forge_legacy_preprocessors/annotator/color/__init__.py

@@ -0,0 +1,24 @@
+import cv2
+
+
+def cv2_resize_shortest_edge(image, size):
+    h, w = image.shape[:2]
+    if h < w:
+        new_h = size
+        new_w = int(round(w / h * size))
+    else:
+        new_w = size
+        new_h = int(round(h / w * size))
+    resized_image = cv2.resize(image, (new_w, new_h), interpolation=cv2.INTER_AREA)
+    return resized_image
+
+
+def apply_color(img, res=512):
+    img = cv2_resize_shortest_edge(img, res)
+    h, w = img.shape[:2]
+
+    input_img_color = cv2.resize(img, (w // 64, h // 64), interpolation=cv2.INTER_CUBIC)
+    input_img_color = cv2.resize(
+        input_img_color, (w, h), interpolation=cv2.INTER_NEAREST
+    )
+    return input_img_color

extensions-builtin/forge_legacy_preprocessors/annotator/densepose/__init__.py

@@ -0,0 +1,80 @@
+import torchvision  # Fix issue Unknown builtin op: torchvision::nms
+import cv2
+import numpy as np
+import torch
+from einops import rearrange
+from .densepose import (
+    DensePoseMaskedColormapResultsVisualizer,
+    _extract_i_from_iuvarr,
+    densepose_chart_predictor_output_to_result_with_confidences,
+)
+from modules import devices
+from annotator.annotator_path import models_path
+import os
+
+N_PART_LABELS = 24
+result_visualizer = DensePoseMaskedColormapResultsVisualizer(
+    alpha=1,
+    data_extractor=_extract_i_from_iuvarr,
+    segm_extractor=_extract_i_from_iuvarr,
+    val_scale=255.0 / N_PART_LABELS,
+)
+remote_torchscript_path = "https://huggingface.co/LayerNorm/DensePose-TorchScript-with-hint-image/resolve/main/densepose_r50_fpn_dl.torchscript"
+torchscript_model = None
+model_dir = os.path.join(models_path, "densepose")
+
+
+def apply_densepose(input_image, cmap="viridis"):
+    global torchscript_model
+    if torchscript_model is None:
+        model_path = os.path.join(model_dir, "densepose_r50_fpn_dl.torchscript")
+        if not os.path.exists(model_path):
+            from modules.modelloader import load_file_from_url
+
+            load_file_from_url(remote_torchscript_path, model_dir=model_dir)
+        torchscript_model = (
+            torch.jit.load(model_path, map_location="cpu")
+            .to(devices.get_device_for("controlnet"))
+            .eval()
+        )
+    H, W = input_image.shape[:2]
+
+    hint_image_canvas = np.zeros([H, W], dtype=np.uint8)
+    hint_image_canvas = np.tile(hint_image_canvas[:, :, np.newaxis], [1, 1, 3])
+    input_image = rearrange(
+        torch.from_numpy(input_image).to(devices.get_device_for("controlnet")),
+        "h w c -> c h w",
+    )
+    pred_boxes, corase_segm, fine_segm, u, v = torchscript_model(input_image)
+
+    extractor = densepose_chart_predictor_output_to_result_with_confidences
+    densepose_results = [
+        extractor(
+            pred_boxes[i : i + 1],
+            corase_segm[i : i + 1],
+            fine_segm[i : i + 1],
+            u[i : i + 1],
+            v[i : i + 1],
+        )
+        for i in range(len(pred_boxes))
+    ]
+
+    if cmap == "viridis":
+        result_visualizer.mask_visualizer.cmap = cv2.COLORMAP_VIRIDIS
+        hint_image = result_visualizer.visualize(hint_image_canvas, densepose_results)
+        hint_image = cv2.cvtColor(hint_image, cv2.COLOR_BGR2RGB)
+        hint_image[:, :, 0][hint_image[:, :, 0] == 0] = 68
+        hint_image[:, :, 1][hint_image[:, :, 1] == 0] = 1
+        hint_image[:, :, 2][hint_image[:, :, 2] == 0] = 84
+    else:
+        result_visualizer.mask_visualizer.cmap = cv2.COLORMAP_PARULA
+        hint_image = result_visualizer.visualize(hint_image_canvas, densepose_results)
+        hint_image = cv2.cvtColor(hint_image, cv2.COLOR_BGR2RGB)
+
+    return hint_image
+
+
+def unload_model():
+    global torchscript_model
+    if torchscript_model is not None:
+        torchscript_model.cpu()

extensions-builtin/forge_legacy_preprocessors/annotator/densepose/densepose.py

@@ -0,0 +1,361 @@
+from typing import Tuple
+import math
+import numpy as np
+from enum import IntEnum
+from typing import List, Tuple, Union
+import torch
+from torch.nn import functional as F
+import logging
+import cv2
+
+Image = np.ndarray
+Boxes = torch.Tensor
+ImageSizeType = Tuple[int, int]
+_RawBoxType = Union[List[float], Tuple[float, ...], torch.Tensor, np.ndarray]
+IntTupleBox = Tuple[int, int, int, int]
+
+
+class BoxMode(IntEnum):
+    """
+    Enum of different ways to represent a box.
+    """
+
+    XYXY_ABS = 0
+    """
+    (x0, y0, x1, y1) in absolute floating points coordinates.
+    The coordinates in range [0, width or height].
+    """
+    XYWH_ABS = 1
+    """
+    (x0, y0, w, h) in absolute floating points coordinates.
+    """
+    XYXY_REL = 2
+    """
+    Not yet supported!
+    (x0, y0, x1, y1) in range [0, 1]. They are relative to the size of the image.
+    """
+    XYWH_REL = 3
+    """
+    Not yet supported!
+    (x0, y0, w, h) in range [0, 1]. They are relative to the size of the image.
+    """
+    XYWHA_ABS = 4
+    """
+    (xc, yc, w, h, a) in absolute floating points coordinates.
+    (xc, yc) is the center of the rotated box, and the angle a is in degrees ccw.
+    """
+
+    @staticmethod
+    def convert(
+        box: _RawBoxType, from_mode: "BoxMode", to_mode: "BoxMode"
+    ) -> _RawBoxType:
+        """
+        Args:
+            box: can be a k-tuple, k-list or an Nxk array/tensor, where k = 4 or 5
+            from_mode, to_mode (BoxMode)
+
+        Returns:
+            The converted box of the same type.
+        """
+        if from_mode == to_mode:
+            return box
+
+        original_type = type(box)
+        is_numpy = isinstance(box, np.ndarray)
+        single_box = isinstance(box, (list, tuple))
+        if single_box:
+            assert len(box) == 4 or len(box) == 5, (
+                "BoxMode.convert takes either a k-tuple/list or an Nxk array/tensor,"
+                " where k == 4 or 5"
+            )
+            arr = torch.tensor(box)[None, :]
+        else:
+            # avoid modifying the input box
+            if is_numpy:
+                arr = torch.from_numpy(np.asarray(box)).clone()
+            else:
+                arr = box.clone()
+
+        assert to_mode not in [
+            BoxMode.XYXY_REL,
+            BoxMode.XYWH_REL,
+        ] and from_mode not in [
+            BoxMode.XYXY_REL,
+            BoxMode.XYWH_REL,
+        ], "Relative mode not yet supported!"
+
+        if from_mode == BoxMode.XYWHA_ABS and to_mode == BoxMode.XYXY_ABS:
+            assert (
+                arr.shape[-1] == 5
+            ), "The last dimension of input shape must be 5 for XYWHA format"
+            original_dtype = arr.dtype
+            arr = arr.double()
+
+            w = arr[:, 2]
+            h = arr[:, 3]
+            a = arr[:, 4]
+            c = torch.abs(torch.cos(a * math.pi / 180.0))
+            s = torch.abs(torch.sin(a * math.pi / 180.0))
+            # This basically computes the horizontal bounding rectangle of the rotated box
+            new_w = c * w + s * h
+            new_h = c * h + s * w
+
+            # convert center to top-left corner
+            arr[:, 0] -= new_w / 2.0
+            arr[:, 1] -= new_h / 2.0
+            # bottom-right corner
+            arr[:, 2] = arr[:, 0] + new_w
+            arr[:, 3] = arr[:, 1] + new_h
+
+            arr = arr[:, :4].to(dtype=original_dtype)
+        elif from_mode == BoxMode.XYWH_ABS and to_mode == BoxMode.XYWHA_ABS:
+            original_dtype = arr.dtype
+            arr = arr.double()
+            arr[:, 0] += arr[:, 2] / 2.0
+            arr[:, 1] += arr[:, 3] / 2.0
+            angles = torch.zeros((arr.shape[0], 1), dtype=arr.dtype)
+            arr = torch.cat((arr, angles), axis=1).to(dtype=original_dtype)
+        else:
+            if to_mode == BoxMode.XYXY_ABS and from_mode == BoxMode.XYWH_ABS:
+                arr[:, 2] += arr[:, 0]
+                arr[:, 3] += arr[:, 1]
+            elif from_mode == BoxMode.XYXY_ABS and to_mode == BoxMode.XYWH_ABS:
+                arr[:, 2] -= arr[:, 0]
+                arr[:, 3] -= arr[:, 1]
+            else:
+                raise NotImplementedError(
+                    "Conversion from BoxMode {} to {} is not supported yet".format(
+                        from_mode, to_mode
+                    )
+                )
+
+        if single_box:
+            return original_type(arr.flatten().tolist())
+        if is_numpy:
+            return arr.numpy()
+        else:
+            return arr
+
+
+class MatrixVisualizer:
+    """
+    Base visualizer for matrix data
+    """
+
+    def __init__(
+        self,
+        inplace=True,
+        cmap=cv2.COLORMAP_PARULA,
+        val_scale=1.0,
+        alpha=0.7,
+        interp_method_matrix=cv2.INTER_LINEAR,
+        interp_method_mask=cv2.INTER_NEAREST,
+    ):
+        self.inplace = inplace
+        self.cmap = cmap
+        self.val_scale = val_scale
+        self.alpha = alpha
+        self.interp_method_matrix = interp_method_matrix
+        self.interp_method_mask = interp_method_mask
+
+    def visualize(self, image_bgr, mask, matrix, bbox_xywh):
+        self._check_image(image_bgr)
+        self._check_mask_matrix(mask, matrix)
+        if self.inplace:
+            image_target_bgr = image_bgr
+        else:
+            image_target_bgr = image_bgr * 0
+        x, y, w, h = [int(v) for v in bbox_xywh]
+        if w <= 0 or h <= 0:
+            return image_bgr
+        mask, matrix = self._resize(mask, matrix, w, h)
+        mask_bg = np.tile((mask == 0)[:, :, np.newaxis], [1, 1, 3])
+        matrix_scaled = matrix.astype(np.float32) * self.val_scale
+        _EPSILON = 1e-6
+        if np.any(matrix_scaled > 255 + _EPSILON):
+            logger = logging.getLogger(__name__)
+            logger.warning(
+                f"Matrix has values > {255 + _EPSILON} after "
+                f"scaling, clipping to [0..255]"
+            )
+        matrix_scaled_8u = matrix_scaled.clip(0, 255).astype(np.uint8)
+        matrix_vis = cv2.applyColorMap(matrix_scaled_8u, self.cmap)
+        matrix_vis[mask_bg] = image_target_bgr[y : y + h, x : x + w, :][mask_bg]
+        image_target_bgr[y : y + h, x : x + w, :] = (
+            image_target_bgr[y : y + h, x : x + w, :] * (1.0 - self.alpha)
+            + matrix_vis * self.alpha
+        )
+        return image_target_bgr.astype(np.uint8)
+
+    def _resize(self, mask, matrix, w, h):
+        if (w != mask.shape[1]) or (h != mask.shape[0]):
+            mask = cv2.resize(mask, (w, h), self.interp_method_mask)
+        if (w != matrix.shape[1]) or (h != matrix.shape[0]):
+            matrix = cv2.resize(matrix, (w, h), self.interp_method_matrix)
+        return mask, matrix
+
+    def _check_image(self, image_rgb):
+        assert len(image_rgb.shape) == 3
+        assert image_rgb.shape[2] == 3
+        assert image_rgb.dtype == np.uint8
+
+    def _check_mask_matrix(self, mask, matrix):
+        assert len(matrix.shape) == 2
+        assert len(mask.shape) == 2
+        assert mask.dtype == np.uint8
+
+
+class DensePoseResultsVisualizer:
+    def visualize(
+        self,
+        image_bgr: Image,
+        results,
+    ) -> Image:
+        context = self.create_visualization_context(image_bgr)
+        for i, result in enumerate(results):
+            boxes_xywh, labels, uv = result
+            iuv_array = torch.cat((labels[None].type(torch.float32), uv * 255.0)).type(
+                torch.uint8
+            )
+            self.visualize_iuv_arr(context, iuv_array.cpu().numpy(), boxes_xywh)
+        image_bgr = self.context_to_image_bgr(context)
+        return image_bgr
+
+    def create_visualization_context(self, image_bgr: Image):
+        return image_bgr
+
+    def visualize_iuv_arr(self, context, iuv_arr: np.ndarray, bbox_xywh) -> None:
+        pass
+
+    def context_to_image_bgr(self, context):
+        return context
+
+    def get_image_bgr_from_context(self, context):
+        return context
+
+
+class DensePoseMaskedColormapResultsVisualizer(DensePoseResultsVisualizer):
+    def __init__(
+        self,
+        data_extractor,
+        segm_extractor,
+        inplace=True,
+        cmap=cv2.COLORMAP_PARULA,
+        alpha=0.7,
+        val_scale=1.0,
+        **kwargs,
+    ):
+        self.mask_visualizer = MatrixVisualizer(
+            inplace=inplace, cmap=cmap, val_scale=val_scale, alpha=alpha
+        )
+        self.data_extractor = data_extractor
+        self.segm_extractor = segm_extractor
+
+    def context_to_image_bgr(self, context):
+        return context
+
+    def visualize_iuv_arr(self, context, iuv_arr: np.ndarray, bbox_xywh) -> None:
+        image_bgr = self.get_image_bgr_from_context(context)
+        matrix = self.data_extractor(iuv_arr)
+        segm = self.segm_extractor(iuv_arr)
+        mask = np.zeros(matrix.shape, dtype=np.uint8)
+        mask[segm > 0] = 1
+        image_bgr = self.mask_visualizer.visualize(image_bgr, mask, matrix, bbox_xywh)
+
+
+def _extract_i_from_iuvarr(iuv_arr):
+    return iuv_arr[0, :, :]
+
+
+def _extract_u_from_iuvarr(iuv_arr):
+    return iuv_arr[1, :, :]
+
+
+def _extract_v_from_iuvarr(iuv_arr):
+    return iuv_arr[2, :, :]
+
+
+def make_int_box(box: torch.Tensor) -> IntTupleBox:
+    int_box = [0, 0, 0, 0]
+    int_box[0], int_box[1], int_box[2], int_box[3] = tuple(box.long().tolist())
+    return int_box[0], int_box[1], int_box[2], int_box[3]
+
+
+def densepose_chart_predictor_output_to_result_with_confidences(
+    boxes: Boxes, coarse_segm, fine_segm, u, v
+):
+    boxes_xyxy_abs = boxes.clone()
+    boxes_xywh_abs = BoxMode.convert(boxes_xyxy_abs, BoxMode.XYXY_ABS, BoxMode.XYWH_ABS)
+    box_xywh = make_int_box(boxes_xywh_abs[0])
+
+    labels = resample_fine_and_coarse_segm_tensors_to_bbox(
+        fine_segm, coarse_segm, box_xywh
+    ).squeeze(0)
+    uv = resample_uv_tensors_to_bbox(u, v, labels, box_xywh)
+    confidences = []
+    return box_xywh, labels, uv
+
+
+def resample_fine_and_coarse_segm_tensors_to_bbox(
+    fine_segm: torch.Tensor, coarse_segm: torch.Tensor, box_xywh_abs: IntTupleBox
+):
+    """
+    Resample fine and coarse segmentation tensors to the given
+    bounding box and derive labels for each pixel of the bounding box
+
+    Args:
+        fine_segm: float tensor of shape [1, C, Hout, Wout]
+        coarse_segm: float tensor of shape [1, K, Hout, Wout]
+        box_xywh_abs (tuple of 4 int): bounding box given by its upper-left
+            corner coordinates, width (W) and height (H)
+    Return:
+        Labels for each pixel of the bounding box, a long tensor of size [1, H, W]
+    """
+    x, y, w, h = box_xywh_abs
+    w = max(int(w), 1)
+    h = max(int(h), 1)
+    # coarse segmentation
+    coarse_segm_bbox = F.interpolate(
+        coarse_segm,
+        (h, w),
+        mode="bilinear",
+        align_corners=False,
+    ).argmax(dim=1)
+    # combined coarse and fine segmentation
+    labels = (
+        F.interpolate(fine_segm, (h, w), mode="bilinear", align_corners=False).argmax(
+            dim=1
+        )
+        * (coarse_segm_bbox > 0).long()
+    )
+    return labels
+
+
+def resample_uv_tensors_to_bbox(
+    u: torch.Tensor,
+    v: torch.Tensor,
+    labels: torch.Tensor,
+    box_xywh_abs: IntTupleBox,
+) -> torch.Tensor:
+    """
+    Resamples U and V coordinate estimates for the given bounding box
+
+    Args:
+        u (tensor [1, C, H, W] of float): U coordinates
+        v (tensor [1, C, H, W] of float): V coordinates
+        labels (tensor [H, W] of long): labels obtained by resampling segmentation
+            outputs for the given bounding box
+        box_xywh_abs (tuple of 4 int): bounding box that corresponds to predictor outputs
+    Return:
+       Resampled U and V coordinates - a tensor [2, H, W] of float
+    """
+    x, y, w, h = box_xywh_abs
+    w = max(int(w), 1)
+    h = max(int(h), 1)
+    u_bbox = F.interpolate(u, (h, w), mode="bilinear", align_corners=False)
+    v_bbox = F.interpolate(v, (h, w), mode="bilinear", align_corners=False)
+    uv = torch.zeros([2, h, w], dtype=torch.float32, device=u.device)
+    for part_id in range(1, u_bbox.size(1)):
+        uv[0][labels == part_id] = u_bbox[0, part_id][labels == part_id]
+        uv[1][labels == part_id] = v_bbox[0, part_id][labels == part_id]
+    return uv

extensions-builtin/forge_legacy_preprocessors/annotator/depth_anything.py

@@ -0,0 +1,81 @@
+import os
+import torch
+import cv2
+import numpy as np
+import torch.nn.functional as F
+from torchvision.transforms import Compose
+
+from depth_anything.dpt import DPT_DINOv2
+from depth_anything.util.transform import Resize, NormalizeImage, PrepareForNet
+from .util import load_model
+from .annotator_path import models_path
+
+
+transform = Compose(
+    [
+        Resize(
+            width=518,
+            height=518,
+            resize_target=False,
+            keep_aspect_ratio=True,
+            ensure_multiple_of=14,
+            resize_method="lower_bound",
+            image_interpolation_method=cv2.INTER_CUBIC,
+        ),
+        NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+        PrepareForNet(),
+    ]
+)
+
+
+class DepthAnythingDetector:
+    """https://github.com/LiheYoung/Depth-Anything"""
+
+    model_dir = os.path.join(models_path, "depth_anything")
+
+    def __init__(self, device: torch.device):
+        self.device = device
+        self.model = (
+            DPT_DINOv2(
+                encoder="vitl",
+                features=256,
+                out_channels=[256, 512, 1024, 1024],
+                localhub=False,
+            )
+            .to(device)
+            .eval()
+        )
+        remote_url = os.environ.get(
+            "CONTROLNET_DEPTH_ANYTHING_MODEL_URL",
+            "https://huggingface.co/spaces/LiheYoung/Depth-Anything/resolve/main/checkpoints/depth_anything_vitl14.pth",
+        )
+        model_path = load_model(
+            "depth_anything_vitl14.pth", remote_url=remote_url, model_dir=self.model_dir
+        )
+        self.model.load_state_dict(torch.load(model_path))
+
+    def __call__(self, image: np.ndarray, colored: bool = True) -> np.ndarray:
+        self.model.to(self.device)
+        h, w = image.shape[:2]
+
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) / 255.0
+        image = transform({"image": image})["image"]
+        image = torch.from_numpy(image).unsqueeze(0).to(self.device)
+
+        @torch.no_grad()
+        def predict_depth(model, image):
+            return model(image)
+
+        depth = predict_depth(self.model, image)
+        depth = F.interpolate(
+            depth[None], (h, w), mode="bilinear", align_corners=False
+        )[0, 0]
+        depth = (depth - depth.min()) / (depth.max() - depth.min()) * 255.0
+        depth = depth.cpu().numpy().astype(np.uint8)
+        if colored:
+            return cv2.applyColorMap(depth, cv2.COLORMAP_INFERNO)[:, :, ::-1]
+        else:
+            return depth
+
+    def unload_model(self):
+        self.model.to("cpu")

extensions-builtin/forge_legacy_preprocessors/annotator/hed/__init__.py

@@ -0,0 +1,137 @@
+# This is an improved version and model of HED edge detection with Apache License, Version 2.0.
+# Please use this implementation in your products
+# This implementation may produce slightly different results from Saining Xie's official implementations,
+# but it generates smoother edges and is more suitable for ControlNet as well as other image-to-image translations.
+# Different from official models and other implementations, this is an RGB-input model (rather than BGR)
+# and in this way it works better for gradio's RGB protocol
+
+import os
+import cv2
+import torch
+import numpy as np
+
+from einops import rearrange
+import os
+from modules import devices
+from annotator.annotator_path import models_path
+from annotator.util import safe_step, nms
+
+
+class DoubleConvBlock(torch.nn.Module):
+    def __init__(self, input_channel, output_channel, layer_number):
+        super().__init__()
+        self.convs = torch.nn.Sequential()
+        self.convs.append(
+            torch.nn.Conv2d(
+                in_channels=input_channel,
+                out_channels=output_channel,
+                kernel_size=(3, 3),
+                stride=(1, 1),
+                padding=1,
+            )
+        )
+        for i in range(1, layer_number):
+            self.convs.append(
+                torch.nn.Conv2d(
+                    in_channels=output_channel,
+                    out_channels=output_channel,
+                    kernel_size=(3, 3),
+                    stride=(1, 1),
+                    padding=1,
+                )
+            )
+        self.projection = torch.nn.Conv2d(
+            in_channels=output_channel,
+            out_channels=1,
+            kernel_size=(1, 1),
+            stride=(1, 1),
+            padding=0,
+        )
+
+    def __call__(self, x, down_sampling=False):
+        h = x
+        if down_sampling:
+            h = torch.nn.functional.max_pool2d(h, kernel_size=(2, 2), stride=(2, 2))
+        for conv in self.convs:
+            h = conv(h)
+            h = torch.nn.functional.relu(h)
+        return h, self.projection(h)
+
+
+class ControlNetHED_Apache2(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.norm = torch.nn.Parameter(torch.zeros(size=(1, 3, 1, 1)))
+        self.block1 = DoubleConvBlock(
+            input_channel=3, output_channel=64, layer_number=2
+        )
+        self.block2 = DoubleConvBlock(
+            input_channel=64, output_channel=128, layer_number=2
+        )
+        self.block3 = DoubleConvBlock(
+            input_channel=128, output_channel=256, layer_number=3
+        )
+        self.block4 = DoubleConvBlock(
+            input_channel=256, output_channel=512, layer_number=3
+        )
+        self.block5 = DoubleConvBlock(
+            input_channel=512, output_channel=512, layer_number=3
+        )
+
+    def __call__(self, x):
+        h = x - self.norm
+        h, projection1 = self.block1(h)
+        h, projection2 = self.block2(h, down_sampling=True)
+        h, projection3 = self.block3(h, down_sampling=True)
+        h, projection4 = self.block4(h, down_sampling=True)
+        h, projection5 = self.block5(h, down_sampling=True)
+        return projection1, projection2, projection3, projection4, projection5
+
+
+netNetwork = None
+remote_model_path = (
+    "https://huggingface.co/lllyasviel/Annotators/resolve/main/ControlNetHED.pth"
+)
+modeldir = os.path.join(models_path, "hed")
+old_modeldir = os.path.dirname(os.path.realpath(__file__))
+
+
+def apply_hed(input_image, is_safe=False):
+    global netNetwork
+    if netNetwork is None:
+        modelpath = os.path.join(modeldir, "ControlNetHED.pth")
+        old_modelpath = os.path.join(old_modeldir, "ControlNetHED.pth")
+        if os.path.exists(old_modelpath):
+            modelpath = old_modelpath
+        elif not os.path.exists(modelpath):
+            from modules.modelloader import load_file_from_url
+
+            load_file_from_url(remote_model_path, model_dir=modeldir)
+        netNetwork = ControlNetHED_Apache2().to(devices.get_device_for("controlnet"))
+        netNetwork.load_state_dict(torch.load(modelpath, map_location="cpu"))
+    netNetwork.to(devices.get_device_for("controlnet")).float().eval()
+
+    assert input_image.ndim == 3
+    H, W, C = input_image.shape
+    with torch.no_grad():
+        image_hed = (
+            torch.from_numpy(input_image.copy())
+            .float()
+            .to(devices.get_device_for("controlnet"))
+        )
+        image_hed = rearrange(image_hed, "h w c -> 1 c h w")
+        edges = netNetwork(image_hed)
+        edges = [e.detach().cpu().numpy().astype(np.float32)[0, 0] for e in edges]
+        edges = [cv2.resize(e, (W, H), interpolation=cv2.INTER_LINEAR) for e in edges]
+        edges = np.stack(edges, axis=2)
+        edge = 1 / (1 + np.exp(-np.mean(edges, axis=2).astype(np.float64)))
+        if is_safe:
+            edge = safe_step(edge)
+        edge = (edge * 255.0).clip(0, 255).astype(np.uint8)
+        return edge
+
+
+def unload_hed_model():
+    global netNetwork
+    if netNetwork is not None:
+        netNetwork.cpu()

extensions-builtin/forge_legacy_preprocessors/annotator/keypose/__init__.py

@@ -0,0 +1,279 @@
+import numpy as np
+import cv2
+import torch
+
+import os
+from modules import devices
+from annotator.annotator_path import models_path
+
+import mmcv
+from mmdet.apis import inference_detector, init_detector
+from mmpose.apis import inference_top_down_pose_model
+from mmpose.apis import init_pose_model, process_mmdet_results, vis_pose_result
+
+
+def preprocessing(image, device):
+    # Resize
+    scale = 640 / max(image.shape[:2])
+    image = cv2.resize(image, dsize=None, fx=scale, fy=scale)
+    raw_image = image.astype(np.uint8)
+
+    # Subtract mean values
+    image = image.astype(np.float32)
+    image -= np.array(
+        [
+            float(104.008),
+            float(116.669),
+            float(122.675),
+        ]
+    )
+
+    # Convert to torch.Tensor and add "batch" axis
+    image = torch.from_numpy(image.transpose(2, 0, 1)).float().unsqueeze(0)
+    image = image.to(device)
+
+    return image, raw_image
+
+
+def imshow_keypoints(
+    img,
+    pose_result,
+    skeleton=None,
+    kpt_score_thr=0.1,
+    pose_kpt_color=None,
+    pose_link_color=None,
+    radius=4,
+    thickness=1,
+):
+    """Draw keypoints and links on an image.
+    Args:
+            img (ndarry): The image to draw poses on.
+            pose_result (list[kpts]): The poses to draw. Each element kpts is
+                a set of K keypoints as an Kx3 numpy.ndarray, where each
+                keypoint is represented as x, y, score.
+            kpt_score_thr (float, optional): Minimum score of keypoints
+                to be shown. Default: 0.3.
+            pose_kpt_color (np.array[Nx3]`): Color of N keypoints. If None,
+                the keypoint will not be drawn.
+            pose_link_color (np.array[Mx3]): Color of M links. If None, the
+                links will not be drawn.
+            thickness (int): Thickness of lines.
+    """
+
+    img_h, img_w, _ = img.shape
+    img = np.zeros(img.shape)
+
+    for idx, kpts in enumerate(pose_result):
+        if idx > 1:
+            continue
+        kpts = kpts["keypoints"]
+        # print(kpts)
+        kpts = np.array(kpts, copy=False)
+
+        # draw each point on image
+        if pose_kpt_color is not None:
+            assert len(pose_kpt_color) == len(kpts)
+
+            for kid, kpt in enumerate(kpts):
+                x_coord, y_coord, kpt_score = int(kpt[0]), int(kpt[1]), kpt[2]
+
+                if kpt_score < kpt_score_thr or pose_kpt_color[kid] is None:
+                    # skip the point that should not be drawn
+                    continue
+
+                color = tuple(int(c) for c in pose_kpt_color[kid])
+                cv2.circle(img, (int(x_coord), int(y_coord)), radius, color, -1)
+
+        # draw links
+        if skeleton is not None and pose_link_color is not None:
+            assert len(pose_link_color) == len(skeleton)
+
+            for sk_id, sk in enumerate(skeleton):
+                pos1 = (int(kpts[sk[0], 0]), int(kpts[sk[0], 1]))
+                pos2 = (int(kpts[sk[1], 0]), int(kpts[sk[1], 1]))
+
+                if (
+                    pos1[0] <= 0
+                    or pos1[0] >= img_w
+                    or pos1[1] <= 0
+                    or pos1[1] >= img_h
+                    or pos2[0] <= 0
+                    or pos2[0] >= img_w
+                    or pos2[1] <= 0
+                    or pos2[1] >= img_h
+                    or kpts[sk[0], 2] < kpt_score_thr
+                    or kpts[sk[1], 2] < kpt_score_thr
+                    or pose_link_color[sk_id] is None
+                ):
+                    # skip the link that should not be drawn
+                    continue
+                color = tuple(int(c) for c in pose_link_color[sk_id])
+                cv2.line(img, pos1, pos2, color, thickness=thickness)
+
+    return img
+
+
+human_det, pose_model = None, None
+det_model_path = "https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth"
+pose_model_path = "https://download.openmmlab.com/mmpose/top_down/hrnet/hrnet_w48_coco_256x192-b9e0b3ab_20200708.pth"
+
+modeldir = os.path.join(models_path, "keypose")
+old_modeldir = os.path.dirname(os.path.realpath(__file__))
+
+det_config = "faster_rcnn_r50_fpn_coco.py"
+pose_config = "hrnet_w48_coco_256x192.py"
+
+det_checkpoint = "faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth"
+pose_checkpoint = "hrnet_w48_coco_256x192-b9e0b3ab_20200708.pth"
+det_cat_id = 1
+bbox_thr = 0.2
+
+skeleton = [
+    [15, 13],
+    [13, 11],
+    [16, 14],
+    [14, 12],
+    [11, 12],
+    [5, 11],
+    [6, 12],
+    [5, 6],
+    [5, 7],
+    [6, 8],
+    [7, 9],
+    [8, 10],
+    [1, 2],
+    [0, 1],
+    [0, 2],
+    [1, 3],
+    [2, 4],
+    [3, 5],
+    [4, 6],
+]
+
+pose_kpt_color = [
+    [51, 153, 255],
+    [51, 153, 255],
+    [51, 153, 255],
+    [51, 153, 255],
+    [51, 153, 255],
+    [0, 255, 0],
+    [255, 128, 0],
+    [0, 255, 0],
+    [255, 128, 0],
+    [0, 255, 0],
+    [255, 128, 0],
+    [0, 255, 0],
+    [255, 128, 0],
+    [0, 255, 0],
+    [255, 128, 0],
+    [0, 255, 0],
+    [255, 128, 0],
+]
+
+pose_link_color = [
+    [0, 255, 0],
+    [0, 255, 0],
+    [255, 128, 0],
+    [255, 128, 0],
+    [51, 153, 255],
+    [51, 153, 255],
+    [51, 153, 255],
+    [51, 153, 255],
+    [0, 255, 0],
+    [255, 128, 0],
+    [0, 255, 0],
+    [255, 128, 0],
+    [51, 153, 255],
+    [51, 153, 255],
+    [51, 153, 255],
+    [51, 153, 255],
+    [51, 153, 255],
+    [51, 153, 255],
+    [51, 153, 255],
+]
+
+
+def find_download_model(checkpoint, remote_path):
+    modelpath = os.path.join(modeldir, checkpoint)
+    old_modelpath = os.path.join(old_modeldir, checkpoint)
+
+    if os.path.exists(old_modelpath):
+        modelpath = old_modelpath
+    elif not os.path.exists(modelpath):
+        from modules.modelloader import load_file_from_url
+
+        load_file_from_url(remote_path, model_dir=modeldir)
+
+    return modelpath
+
+
+def apply_keypose(input_image):
+    global human_det, pose_model
+    if netNetwork is None:
+        det_model_local = find_download_model(det_checkpoint, det_model_path)
+        hrnet_model_local = find_download_model(pose_checkpoint, pose_model_path)
+        det_config_mmcv = mmcv.Config.fromfile(det_config)
+        pose_config_mmcv = mmcv.Config.fromfile(pose_config)
+        human_det = init_detector(
+            det_config_mmcv,
+            det_model_local,
+            device=devices.get_device_for("controlnet"),
+        )
+        pose_model = init_pose_model(
+            pose_config_mmcv,
+            hrnet_model_local,
+            device=devices.get_device_for("controlnet"),
+        )
+
+    assert input_image.ndim == 3
+    input_image = input_image.copy()
+    with torch.no_grad():
+        image = (
+            torch.from_numpy(input_image)
+            .float()
+            .to(devices.get_device_for("controlnet"))
+        )
+        image = image / 255.0
+        mmdet_results = inference_detector(human_det, image)
+
+        # keep the person class bounding boxes.
+        person_results = process_mmdet_results(mmdet_results, det_cat_id)
+
+        return_heatmap = False
+        dataset = pose_model.cfg.data["test"]["type"]
+
+        # e.g. use ('backbone', ) to return backbone feature
+        output_layer_names = None
+        pose_results, _ = inference_top_down_pose_model(
+            pose_model,
+            image,
+            person_results,
+            bbox_thr=bbox_thr,
+            format="xyxy",
+            dataset=dataset,
+            dataset_info=None,
+            return_heatmap=return_heatmap,
+            outputs=output_layer_names,
+        )
+
+        im_keypose_out = imshow_keypoints(
+            image,
+            pose_results,
+            skeleton=skeleton,
+            pose_kpt_color=pose_kpt_color,
+            pose_link_color=pose_link_color,
+            radius=2,
+            thickness=2,
+        )
+        im_keypose_out = im_keypose_out.astype(np.uint8)
+
+        # image_hed = rearrange(image_hed, 'h w c -> 1 c h w')
+        # edge = netNetwork(image_hed)[0]
+        # edge = (edge.cpu().numpy() * 255.0).clip(0, 255).astype(np.uint8)
+        return im_keypose_out
+
+
+def unload_hed_model():
+    global netNetwork
+    if netNetwork is not None:
+        netNetwork.cpu()

extensions-builtin/forge_legacy_preprocessors/annotator/keypose/faster_rcnn_r50_fpn_coco.py

@@ -0,0 +1,198 @@
+checkpoint_config = dict(interval=1)
+# yapf:disable
+log_config = dict(
+    interval=50,
+    hooks=[
+        dict(type='TextLoggerHook'),
+        # dict(type='TensorboardLoggerHook')
+    ])
+# yapf:enable
+dist_params = dict(backend="nccl")
+log_level = "INFO"
+load_from = None
+resume_from = None
+workflow = [("train", 1)]
+# optimizer
+optimizer = dict(type="SGD", lr=0.02, momentum=0.9, weight_decay=0.0001)
+optimizer_config = dict(grad_clip=None)
+# learning policy
+lr_config = dict(
+    policy="step", warmup="linear", warmup_iters=500, warmup_ratio=0.001, step=[8, 11]
+)
+total_epochs = 12
+
+model = dict(
+    type="FasterRCNN",
+    pretrained="torchvision://resnet50",
+    backbone=dict(
+        type="ResNet",
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=1,
+        norm_cfg=dict(type="BN", requires_grad=True),
+        norm_eval=True,
+        style="pytorch",
+    ),
+    neck=dict(
+        type="FPN", in_channels=[256, 512, 1024, 2048], out_channels=256, num_outs=5
+    ),
+    rpn_head=dict(
+        type="RPNHead",
+        in_channels=256,
+        feat_channels=256,
+        anchor_generator=dict(
+            type="AnchorGenerator",
+            scales=[8],
+            ratios=[0.5, 1.0, 2.0],
+            strides=[4, 8, 16, 32, 64],
+        ),
+        bbox_coder=dict(
+            type="DeltaXYWHBBoxCoder",
+            target_means=[0.0, 0.0, 0.0, 0.0],
+            target_stds=[1.0, 1.0, 1.0, 1.0],
+        ),
+        loss_cls=dict(type="CrossEntropyLoss", use_sigmoid=True, loss_weight=1.0),
+        loss_bbox=dict(type="L1Loss", loss_weight=1.0),
+    ),
+    roi_head=dict(
+        type="StandardRoIHead",
+        bbox_roi_extractor=dict(
+            type="SingleRoIExtractor",
+            roi_layer=dict(type="RoIAlign", output_size=7, sampling_ratio=0),
+            out_channels=256,
+            featmap_strides=[4, 8, 16, 32],
+        ),
+        bbox_head=dict(
+            type="Shared2FCBBoxHead",
+            in_channels=256,
+            fc_out_channels=1024,
+            roi_feat_size=7,
+            num_classes=80,
+            bbox_coder=dict(
+                type="DeltaXYWHBBoxCoder",
+                target_means=[0.0, 0.0, 0.0, 0.0],
+                target_stds=[0.1, 0.1, 0.2, 0.2],
+            ),
+            reg_class_agnostic=False,
+            loss_cls=dict(type="CrossEntropyLoss", use_sigmoid=False, loss_weight=1.0),
+            loss_bbox=dict(type="L1Loss", loss_weight=1.0),
+        ),
+    ),
+    # model training and testing settings
+    train_cfg=dict(
+        rpn=dict(
+            assigner=dict(
+                type="MaxIoUAssigner",
+                pos_iou_thr=0.7,
+                neg_iou_thr=0.3,
+                min_pos_iou=0.3,
+                match_low_quality=True,
+                ignore_iof_thr=-1,
+            ),
+            sampler=dict(
+                type="RandomSampler",
+                num=256,
+                pos_fraction=0.5,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=False,
+            ),
+            allowed_border=-1,
+            pos_weight=-1,
+            debug=False,
+        ),
+        rpn_proposal=dict(
+            nms_pre=2000,
+            max_per_img=1000,
+            nms=dict(type="nms", iou_threshold=0.7),
+            min_bbox_size=0,
+        ),
+        rcnn=dict(
+            assigner=dict(
+                type="MaxIoUAssigner",
+                pos_iou_thr=0.5,
+                neg_iou_thr=0.5,
+                min_pos_iou=0.5,
+                match_low_quality=False,
+                ignore_iof_thr=-1,
+            ),
+            sampler=dict(
+                type="RandomSampler",
+                num=512,
+                pos_fraction=0.25,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=True,
+            ),
+            pos_weight=-1,
+            debug=False,
+        ),
+    ),
+    test_cfg=dict(
+        rpn=dict(
+            nms_pre=1000,
+            max_per_img=1000,
+            nms=dict(type="nms", iou_threshold=0.7),
+            min_bbox_size=0,
+        ),
+        rcnn=dict(
+            score_thr=0.05, nms=dict(type="nms", iou_threshold=0.5), max_per_img=100
+        ),
+        # soft-nms is also supported for rcnn testing
+        # e.g., nms=dict(type='soft_nms', iou_threshold=0.5, min_score=0.05)
+    ),
+)
+
+dataset_type = "CocoDataset"
+data_root = "data/coco"
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True
+)
+train_pipeline = [
+    dict(type="LoadImageFromFile"),
+    dict(type="LoadAnnotations", with_bbox=True),
+    dict(type="Resize", img_scale=(1333, 800), keep_ratio=True),
+    dict(type="RandomFlip", flip_ratio=0.5),
+    dict(type="Normalize", **img_norm_cfg),
+    dict(type="Pad", size_divisor=32),
+    dict(type="DefaultFormatBundle"),
+    dict(type="Collect", keys=["img", "gt_bboxes", "gt_labels"]),
+]
+test_pipeline = [
+    dict(type="LoadImageFromFile"),
+    dict(
+        type="MultiScaleFlipAug",
+        img_scale=(1333, 800),
+        flip=False,
+        transforms=[
+            dict(type="Resize", keep_ratio=True),
+            dict(type="RandomFlip"),
+            dict(type="Normalize", **img_norm_cfg),
+            dict(type="Pad", size_divisor=32),
+            dict(type="DefaultFormatBundle"),
+            dict(type="Collect", keys=["img"]),
+        ],
+    ),
+]
+data = dict(
+    samples_per_gpu=2,
+    workers_per_gpu=2,
+    train=dict(
+        type=dataset_type,
+        ann_file=f"{data_root}/annotations/instances_train2017.json",
+        img_prefix=f"{data_root}/train2017/",
+        pipeline=train_pipeline,
+    ),
+    val=dict(
+        type=dataset_type,
+        ann_file=f"{data_root}/annotations/instances_val2017.json",
+        img_prefix=f"{data_root}/val2017/",
+        pipeline=test_pipeline,
+    ),
+    test=dict(
+        type=dataset_type,
+        ann_file=f"{data_root}/annotations/instances_val2017.json",
+        img_prefix=f"{data_root}/val2017/",
+        pipeline=test_pipeline,
+    ),
+)
+evaluation = dict(interval=1, metric="bbox")

extensions-builtin/forge_legacy_preprocessors/annotator/keypose/hrnet_w48_coco_256x192.py

@@ -0,0 +1,181 @@
+# _base_ = [
+#     '../../../../_base_/default_runtime.py',
+#     '../../../../_base_/datasets/coco.py'
+# ]
+evaluation = dict(interval=10, metric="mAP", save_best="AP")
+
+optimizer = dict(
+    type="Adam",
+    lr=5e-4,
+)
+optimizer_config = dict(grad_clip=None)
+# learning policy
+lr_config = dict(
+    policy="step",
+    warmup="linear",
+    warmup_iters=500,
+    warmup_ratio=0.001,
+    step=[170, 200],
+)
+total_epochs = 210
+channel_cfg = dict(
+    num_output_channels=17,
+    dataset_joints=17,
+    dataset_channel=[
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+    ],
+    inference_channel=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+)
+
+# model settings
+model = dict(
+    type="TopDown",
+    pretrained="https://download.openmmlab.com/mmpose/"
+    "pretrain_models/hrnet_w48-8ef0771d.pth",
+    backbone=dict(
+        type="HRNet",
+        in_channels=3,
+        extra=dict(
+            stage1=dict(
+                num_modules=1,
+                num_branches=1,
+                block="BOTTLENECK",
+                num_blocks=(4,),
+                num_channels=(64,),
+            ),
+            stage2=dict(
+                num_modules=1,
+                num_branches=2,
+                block="BASIC",
+                num_blocks=(4, 4),
+                num_channels=(48, 96),
+            ),
+            stage3=dict(
+                num_modules=4,
+                num_branches=3,
+                block="BASIC",
+                num_blocks=(4, 4, 4),
+                num_channels=(48, 96, 192),
+            ),
+            stage4=dict(
+                num_modules=3,
+                num_branches=4,
+                block="BASIC",
+                num_blocks=(4, 4, 4, 4),
+                num_channels=(48, 96, 192, 384),
+            ),
+        ),
+    ),
+    keypoint_head=dict(
+        type="TopdownHeatmapSimpleHead",
+        in_channels=48,
+        out_channels=channel_cfg["num_output_channels"],
+        num_deconv_layers=0,
+        extra=dict(
+            final_conv_kernel=1,
+        ),
+        loss_keypoint=dict(type="JointsMSELoss", use_target_weight=True),
+    ),
+    train_cfg=dict(),
+    test_cfg=dict(
+        flip_test=True, post_process="default", shift_heatmap=True, modulate_kernel=11
+    ),
+)
+
+data_cfg = dict(
+    image_size=[192, 256],
+    heatmap_size=[48, 64],
+    num_output_channels=channel_cfg["num_output_channels"],
+    num_joints=channel_cfg["dataset_joints"],
+    dataset_channel=channel_cfg["dataset_channel"],
+    inference_channel=channel_cfg["inference_channel"],
+    soft_nms=False,
+    nms_thr=1.0,
+    oks_thr=0.9,
+    vis_thr=0.2,
+    use_gt_bbox=False,
+    det_bbox_thr=0.0,
+    bbox_file="data/coco/person_detection_results/"
+    "COCO_val2017_detections_AP_H_56_person.json",
+)
+
+train_pipeline = [
+    dict(type="LoadImageFromFile"),
+    dict(type="TopDownGetBboxCenterScale", padding=1.25),
+    dict(type="TopDownRandomShiftBboxCenter", shift_factor=0.16, prob=0.3),
+    dict(type="TopDownRandomFlip", flip_prob=0.5),
+    dict(type="TopDownHalfBodyTransform", num_joints_half_body=8, prob_half_body=0.3),
+    dict(type="TopDownGetRandomScaleRotation", rot_factor=40, scale_factor=0.5),
+    dict(type="TopDownAffine"),
+    dict(type="ToTensor"),
+    dict(type="NormalizeTensor", mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    dict(type="TopDownGenerateTarget", sigma=2),
+    dict(
+        type="Collect",
+        keys=["img", "target", "target_weight"],
+        meta_keys=[
+            "image_file",
+            "joints_3d",
+            "joints_3d_visible",
+            "center",
+            "scale",
+            "rotation",
+            "bbox_score",
+            "flip_pairs",
+        ],
+    ),
+]
+
+val_pipeline = [
+    dict(type="LoadImageFromFile"),
+    dict(type="TopDownGetBboxCenterScale", padding=1.25),
+    dict(type="TopDownAffine"),
+    dict(type="ToTensor"),
+    dict(type="NormalizeTensor", mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    dict(
+        type="Collect",
+        keys=["img"],
+        meta_keys=[
+            "image_file",
+            "center",
+            "scale",
+            "rotation",
+            "bbox_score",
+            "flip_pairs",
+        ],
+    ),
+]
+
+test_pipeline = val_pipeline
+
+data_root = "data/coco"
+data = dict(
+    samples_per_gpu=32,
+    workers_per_gpu=2,
+    val_dataloader=dict(samples_per_gpu=32),
+    test_dataloader=dict(samples_per_gpu=32),
+    train=dict(
+        type="TopDownCocoDataset",
+        ann_file=f"{data_root}/annotations/person_keypoints_train2017.json",
+        img_prefix=f"{data_root}/train2017/",
+        data_cfg=data_cfg,
+        pipeline=train_pipeline,
+        dataset_info={{_base_.dataset_info}},
+    ),
+    val=dict(
+        type="TopDownCocoDataset",
+        ann_file=f"{data_root}/annotations/person_keypoints_val2017.json",
+        img_prefix=f"{data_root}/val2017/",
+        data_cfg=data_cfg,
+        pipeline=val_pipeline,
+        dataset_info={{_base_.dataset_info}},
+    ),
+    test=dict(
+        type="TopDownCocoDataset",
+        ann_file=f"{data_root}/annotations/person_keypoints_val2017.json",
+        img_prefix=f"{data_root}/val2017/",
+        data_cfg=data_cfg,
+        pipeline=test_pipeline,
+        dataset_info={{_base_.dataset_info}},
+    ),
+)

extensions-builtin/forge_legacy_preprocessors/annotator/leres/__init__.py

@@ -0,0 +1,124 @@
+import cv2
+import numpy as np
+import torch
+import os
+from modules import devices, shared
+from annotator.annotator_path import models_path
+from torchvision.transforms import transforms
+
+# AdelaiDepth/LeReS imports
+from .leres.depthmap import estimateleres, estimateboost
+from .leres.multi_depth_model_woauxi import RelDepthModel
+from .leres.net_tools import strip_prefix_if_present
+
+# pix2pix/merge net imports
+from .pix2pix.options.test_options import TestOptions
+from .pix2pix.models.pix2pix4depth_model import Pix2Pix4DepthModel
+
+base_model_path = os.path.join(models_path, "leres")
+old_modeldir = os.path.dirname(os.path.realpath(__file__))
+
+remote_model_path_leres = (
+    "https://huggingface.co/lllyasviel/Annotators/resolve/main/res101.pth"
+)
+remote_model_path_pix2pix = (
+    "https://huggingface.co/lllyasviel/Annotators/resolve/main/latest_net_G.pth"
+)
+
+model = None
+pix2pixmodel = None
+
+
+def unload_leres_model():
+    global model, pix2pixmodel
+    if model is not None:
+        model = model.cpu()
+    if pix2pixmodel is not None:
+        pix2pixmodel = pix2pixmodel.unload_network("G")
+
+
+def apply_leres(input_image, thr_a, thr_b, boost=False):
+    global model, pix2pixmodel
+    if model is None:
+        model_path = os.path.join(base_model_path, "res101.pth")
+        old_model_path = os.path.join(old_modeldir, "res101.pth")
+
+        if os.path.exists(old_model_path):
+            model_path = old_model_path
+        elif not os.path.exists(model_path):
+            from modules.modelloader import load_file_from_url
+
+            load_file_from_url(remote_model_path_leres, model_dir=base_model_path)
+
+        if torch.cuda.is_available():
+            checkpoint = torch.load(model_path)
+        else:
+            checkpoint = torch.load(model_path, map_location=torch.device("cpu"))
+
+        model = RelDepthModel(backbone="resnext101")
+        model.load_state_dict(
+            strip_prefix_if_present(checkpoint["depth_model"], "module."), strict=True
+        )
+        del checkpoint
+
+    if boost and pix2pixmodel is None:
+        pix2pixmodel_path = os.path.join(base_model_path, "latest_net_G.pth")
+        if not os.path.exists(pix2pixmodel_path):
+            from modules.modelloader import load_file_from_url
+
+            load_file_from_url(remote_model_path_pix2pix, model_dir=base_model_path)
+
+        opt = TestOptions().parse()
+        if not torch.cuda.is_available():
+            opt.gpu_ids = []  # cpu mode
+        pix2pixmodel = Pix2Pix4DepthModel(opt)
+        pix2pixmodel.save_dir = base_model_path
+        pix2pixmodel.load_networks("latest")
+        pix2pixmodel.eval()
+
+    if devices.get_device_for("controlnet").type != "mps":
+        model = model.to(devices.get_device_for("controlnet"))
+
+    assert input_image.ndim == 3
+    height, width, dim = input_image.shape
+
+    with torch.no_grad():
+        if boost:
+            pix2pixmodel.netG.to(devices.get_device_for("controlnet"))
+            depth = estimateboost(
+                input_image, model, 0, pix2pixmodel, max(width, height)
+            )
+        else:
+            depth = estimateleres(input_image, model, width, height)
+
+        numbytes = 2
+        depth_min = depth.min()
+        depth_max = depth.max()
+        max_val = (2 ** (8 * numbytes)) - 1
+
+        # check output before normalizing and mapping to 16 bit
+        if depth_max - depth_min > np.finfo("float").eps:
+            out = max_val * (depth - depth_min) / (depth_max - depth_min)
+        else:
+            out = np.zeros(depth.shape)
+
+        # single channel, 16 bit image
+        depth_image = out.astype("uint16")
+
+        # convert to uint8
+        depth_image = cv2.convertScaleAbs(depth_image, alpha=(255.0 / 65535.0))
+
+        # remove near
+        if thr_a != 0:
+            thr_a = (thr_a / 100) * 255
+            depth_image = cv2.threshold(depth_image, thr_a, 255, cv2.THRESH_TOZERO)[1]
+
+        # invert image
+        depth_image = cv2.bitwise_not(depth_image)
+
+        # remove bg
+        if thr_b != 0:
+            thr_b = (thr_b / 100) * 255
+            depth_image = cv2.threshold(depth_image, thr_b, 255, cv2.THRESH_TOZERO)[1]
+
+        return depth_image

extensions-builtin/forge_legacy_preprocessors/annotator/leres/leres/LICENSE

@@ -0,0 +1,23 @@
+https://github.com/thygate/stable-diffusion-webui-depthmap-script
+
+MIT License
+
+Copyright (c) 2023 Bob Thiry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

extensions-builtin/forge_legacy_preprocessors/annotator/leres/leres/Resnet.py

@@ -0,0 +1,205 @@
+import torch.nn as nn
+import torch.nn as NN
+
+__all__ = ["ResNet", "resnet18", "resnet34", "resnet50", "resnet101", "resnet152"]
+
+
+model_urls = {
+    "resnet18": "https://download.pytorch.org/models/resnet18-5c106cde.pth",
+    "resnet34": "https://download.pytorch.org/models/resnet34-333f7ec4.pth",
+    "resnet50": "https://download.pytorch.org/models/resnet50-19c8e357.pth",
+    "resnet101": "https://download.pytorch.org/models/resnet101-5d3b4d8f.pth",
+    "resnet152": "https://download.pytorch.org/models/resnet152-b121ed2d.pth",
+}
+
+
+def conv3x3(in_planes, out_planes, stride=1):
+    """3x3 convolution with padding"""
+    return nn.Conv2d(
+        in_planes, out_planes, kernel_size=3, stride=stride, padding=1, bias=False
+    )
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(BasicBlock, self).__init__()
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = NN.BatchNorm2d(planes)  # NN.BatchNorm2d
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes)
+        self.bn2 = NN.BatchNorm2d(planes)  # NN.BatchNorm2d
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(Bottleneck, self).__init__()
+        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
+        self.bn1 = NN.BatchNorm2d(planes)  # NN.BatchNorm2d
+        self.conv2 = nn.Conv2d(
+            planes, planes, kernel_size=3, stride=stride, padding=1, bias=False
+        )
+        self.bn2 = NN.BatchNorm2d(planes)  # NN.BatchNorm2d
+        self.conv3 = nn.Conv2d(
+            planes, planes * self.expansion, kernel_size=1, bias=False
+        )
+        self.bn3 = NN.BatchNorm2d(planes * self.expansion)  # NN.BatchNorm2d
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class ResNet(nn.Module):
+    def __init__(self, block, layers, num_classes=1000):
+        self.inplanes = 64
+        super(ResNet, self).__init__()
+        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
+        self.bn1 = NN.BatchNorm2d(64)  # NN.BatchNorm2d
+        self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
+        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
+        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
+        # self.avgpool = nn.AvgPool2d(7, stride=1)
+        # self.fc = nn.Linear(512 * block.expansion, num_classes)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+    def _make_layer(self, block, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(
+                    self.inplanes,
+                    planes * block.expansion,
+                    kernel_size=1,
+                    stride=stride,
+                    bias=False,
+                ),
+                NN.BatchNorm2d(planes * block.expansion),  # NN.BatchNorm2d
+            )
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample))
+        self.inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(block(self.inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        features = []
+
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+
+        x = self.layer1(x)
+        features.append(x)
+        x = self.layer2(x)
+        features.append(x)
+        x = self.layer3(x)
+        features.append(x)
+        x = self.layer4(x)
+        features.append(x)
+
+        return features
+
+
+def resnet18(pretrained=True, **kwargs):
+    """Constructs a ResNet-18 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)
+    return model
+
+
+def resnet34(pretrained=True, **kwargs):
+    """Constructs a ResNet-34 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs)
+    return model
+
+
+def resnet50(pretrained=True, **kwargs):
+    """Constructs a ResNet-50 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs)
+
+    return model
+
+
+def resnet101(pretrained=True, **kwargs):
+    """Constructs a ResNet-101 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(Bottleneck, [3, 4, 23, 3], **kwargs)
+
+    return model
+
+
+def resnet152(pretrained=True, **kwargs):
+    """Constructs a ResNet-152 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(Bottleneck, [3, 8, 36, 3], **kwargs)
+    return model

extensions-builtin/forge_legacy_preprocessors/annotator/leres/leres/Resnext_torch.py

@@ -0,0 +1,291 @@
+#!/usr/bin/env python
+# coding: utf-8
+import torch.nn as nn
+
+try:
+    from urllib import urlretrieve
+except ImportError:
+    from urllib.request import urlretrieve
+
+__all__ = ["resnext101_32x8d"]
+
+
+model_urls = {
+    "resnext50_32x4d": "https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth",
+    "resnext101_32x8d": "https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth",
+}
+
+
+def conv3x3(in_planes, out_planes, stride=1, groups=1, dilation=1):
+    """3x3 convolution with padding"""
+    return nn.Conv2d(
+        in_planes,
+        out_planes,
+        kernel_size=3,
+        stride=stride,
+        padding=dilation,
+        groups=groups,
+        bias=False,
+        dilation=dilation,
+    )
+
+
+def conv1x1(in_planes, out_planes, stride=1):
+    """1x1 convolution"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(
+        self,
+        inplanes,
+        planes,
+        stride=1,
+        downsample=None,
+        groups=1,
+        base_width=64,
+        dilation=1,
+        norm_layer=None,
+    ):
+        super(BasicBlock, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        if groups != 1 or base_width != 64:
+            raise ValueError("BasicBlock only supports groups=1 and base_width=64")
+        if dilation > 1:
+            raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
+        # Both self.conv1 and self.downsample layers downsample the input when stride != 1
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = norm_layer(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes)
+        self.bn2 = norm_layer(planes)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        out = self.relu(out)
+
+        return out
+
+
+class Bottleneck(nn.Module):
+    # Bottleneck in torchvision places the stride for downsampling at 3x3 convolution(self.conv2)
+    # while original implementation places the stride at the first 1x1 convolution(self.conv1)
+    # according to "Deep residual learning for image recognition"https://arxiv.org/abs/1512.03385.
+    # This variant is also known as ResNet V1.5 and improves accuracy according to
+    # https://ngc.nvidia.com/catalog/model-scripts/nvidia:resnet_50_v1_5_for_pytorch.
+
+    expansion = 4
+
+    def __init__(
+        self,
+        inplanes,
+        planes,
+        stride=1,
+        downsample=None,
+        groups=1,
+        base_width=64,
+        dilation=1,
+        norm_layer=None,
+    ):
+        super(Bottleneck, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        width = int(planes * (base_width / 64.0)) * groups
+        # Both self.conv2 and self.downsample layers downsample the input when stride != 1
+        self.conv1 = conv1x1(inplanes, width)
+        self.bn1 = norm_layer(width)
+        self.conv2 = conv3x3(width, width, stride, groups, dilation)
+        self.bn2 = norm_layer(width)
+        self.conv3 = conv1x1(width, planes * self.expansion)
+        self.bn3 = norm_layer(planes * self.expansion)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        out = self.relu(out)
+
+        return out
+
+
+class ResNet(nn.Module):
+    def __init__(
+        self,
+        block,
+        layers,
+        num_classes=1000,
+        zero_init_residual=False,
+        groups=1,
+        width_per_group=64,
+        replace_stride_with_dilation=None,
+        norm_layer=None,
+    ):
+        super(ResNet, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        self._norm_layer = norm_layer
+
+        self.inplanes = 64
+        self.dilation = 1
+        if replace_stride_with_dilation is None:
+            # each element in the tuple indicates if we should replace
+            # the 2x2 stride with a dilated convolution instead
+            replace_stride_with_dilation = [False, False, False]
+        if len(replace_stride_with_dilation) != 3:
+            raise ValueError(
+                "replace_stride_with_dilation should be None "
+                "or a 3-element tuple, got {}".format(replace_stride_with_dilation)
+            )
+        self.groups = groups
+        self.base_width = width_per_group
+        self.conv1 = nn.Conv2d(
+            3, self.inplanes, kernel_size=7, stride=2, padding=3, bias=False
+        )
+        self.bn1 = norm_layer(self.inplanes)
+        self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        self.layer2 = self._make_layer(
+            block, 128, layers[1], stride=2, dilate=replace_stride_with_dilation[0]
+        )
+        self.layer3 = self._make_layer(
+            block, 256, layers[2], stride=2, dilate=replace_stride_with_dilation[1]
+        )
+        self.layer4 = self._make_layer(
+            block, 512, layers[3], stride=2, dilate=replace_stride_with_dilation[2]
+        )
+        # self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+        # self.fc = nn.Linear(512 * block.expansion, num_classes)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
+            elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+        # Zero-initialize the last BN in each residual branch,
+        # so that the residual branch starts with zeros, and each residual block behaves like an identity.
+        # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
+        if zero_init_residual:
+            for m in self.modules():
+                if isinstance(m, Bottleneck):
+                    nn.init.constant_(m.bn3.weight, 0)
+                elif isinstance(m, BasicBlock):
+                    nn.init.constant_(m.bn2.weight, 0)
+
+    def _make_layer(self, block, planes, blocks, stride=1, dilate=False):
+        norm_layer = self._norm_layer
+        downsample = None
+        previous_dilation = self.dilation
+        if dilate:
+            self.dilation *= stride
+            stride = 1
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                conv1x1(self.inplanes, planes * block.expansion, stride),
+                norm_layer(planes * block.expansion),
+            )
+
+        layers = []
+        layers.append(
+            block(
+                self.inplanes,
+                planes,
+                stride,
+                downsample,
+                self.groups,
+                self.base_width,
+                previous_dilation,
+                norm_layer,
+            )
+        )
+        self.inplanes = planes * block.expansion
+        for _ in range(1, blocks):
+            layers.append(
+                block(
+                    self.inplanes,
+                    planes,
+                    groups=self.groups,
+                    base_width=self.base_width,
+                    dilation=self.dilation,
+                    norm_layer=norm_layer,
+                )
+            )
+
+        return nn.Sequential(*layers)
+
+    def _forward_impl(self, x):
+        # See note [TorchScript super()]
+        features = []
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+
+        x = self.layer1(x)
+        features.append(x)
+
+        x = self.layer2(x)
+        features.append(x)
+
+        x = self.layer3(x)
+        features.append(x)
+
+        x = self.layer4(x)
+        features.append(x)
+
+        # x = self.avgpool(x)
+        # x = torch.flatten(x, 1)
+        # x = self.fc(x)
+
+        return features
+
+    def forward(self, x):
+        return self._forward_impl(x)
+
+
+def resnext101_32x8d(pretrained=True, **kwargs):
+    """Constructs a ResNet-152 model.
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    kwargs["groups"] = 32
+    kwargs["width_per_group"] = 8
+
+    model = ResNet(Bottleneck, [3, 4, 23, 3], **kwargs)
+    return model

extensions-builtin/forge_legacy_preprocessors/annotator/leres/leres/depthmap.py

@@ -0,0 +1,666 @@
+# Author: thygate
+# https://github.com/thygate/stable-diffusion-webui-depthmap-script
+
+from modules import devices
+from modules.shared import opts
+from torchvision.transforms import transforms
+from operator import getitem
+
+import torch, gc
+import cv2
+import numpy as np
+import skimage.measure
+
+whole_size_threshold = 1600  # R_max from the paper
+pix2pixsize = 1024
+
+
+def scale_torch(img):
+    """
+    Scale the image and output it in torch.tensor.
+    :param img: input rgb is in shape [H, W, C], input depth/disp is in shape [H, W]
+    :param scale: the scale factor. float
+    :return: img. [C, H, W]
+    """
+    if len(img.shape) == 2:
+        img = img[np.newaxis, :, :]
+    if img.shape[2] == 3:
+        transform = transforms.Compose(
+            [
+                transforms.ToTensor(),
+                transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
+            ]
+        )
+        img = transform(img.astype(np.float32))
+    else:
+        img = img.astype(np.float32)
+        img = torch.from_numpy(img)
+    return img
+
+
+def estimateleres(img, model, w, h):
+    # leres transform input
+    rgb_c = img[:, :, ::-1].copy()
+    A_resize = cv2.resize(rgb_c, (w, h))
+    img_torch = scale_torch(A_resize)[None, :, :, :]
+
+    # compute
+    with torch.no_grad():
+        img_torch = img_torch.to(devices.get_device_for("controlnet"))
+        prediction = model.depth_model(img_torch)
+
+    prediction = prediction.squeeze().cpu().numpy()
+    prediction = cv2.resize(
+        prediction, (img.shape[1], img.shape[0]), interpolation=cv2.INTER_CUBIC
+    )
+
+    return prediction
+
+
+def generatemask(size):
+    # Generates a Guassian mask
+    mask = np.zeros(size, dtype=np.float32)
+    sigma = int(size[0] / 16)
+    k_size = int(2 * np.ceil(2 * int(size[0] / 16)) + 1)
+    mask[
+        int(0.15 * size[0]) : size[0] - int(0.15 * size[0]),
+        int(0.15 * size[1]) : size[1] - int(0.15 * size[1]),
+    ] = 1
+    mask = cv2.GaussianBlur(mask, (int(k_size), int(k_size)), sigma)
+    mask = (mask - mask.min()) / (mask.max() - mask.min())
+    mask = mask.astype(np.float32)
+    return mask
+
+
+def resizewithpool(img, size):
+    i_size = img.shape[0]
+    n = int(np.floor(i_size / size))
+
+    out = skimage.measure.block_reduce(img, (n, n), np.max)
+    return out
+
+
+def rgb2gray(rgb):
+    # Converts rgb to gray
+    return np.dot(rgb[..., :3], [0.2989, 0.5870, 0.1140])
+
+
+def calculateprocessingres(
+    img, basesize, confidence=0.1, scale_threshold=3, whole_size_threshold=3000
+):
+    # Returns the R_x resolution described in section 5 of the main paper.
+
+    # Parameters:
+    #    img :input rgb image
+    #    basesize : size the dilation kernel which is equal to receptive field of the network.
+    #    confidence: value of x in R_x; allowed percentage of pixels that are not getting any contextual cue.
+    #    scale_threshold: maximum allowed upscaling on the input image ; it has been set to 3.
+    #    whole_size_threshold: maximum allowed resolution. (R_max from section 6 of the main paper)
+
+    # Returns:
+    #    outputsize_scale*speed_scale :The computed R_x resolution
+    #    patch_scale: K parameter from section 6 of the paper
+
+    # speed scale parameter is to process every image in a smaller size to accelerate the R_x resolution search
+    speed_scale = 32
+    image_dim = int(min(img.shape[0:2]))
+
+    gray = rgb2gray(img)
+    grad = np.abs(cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)) + np.abs(
+        cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
+    )
+    grad = cv2.resize(grad, (image_dim, image_dim), cv2.INTER_AREA)
+
+    # thresholding the gradient map to generate the edge-map as a proxy of the contextual cues
+    m = grad.min()
+    M = grad.max()
+    middle = m + (0.4 * (M - m))
+    grad[grad < middle] = 0
+    grad[grad >= middle] = 1
+
+    # dilation kernel with size of the receptive field
+    kernel = np.ones((int(basesize / speed_scale), int(basesize / speed_scale)), float)
+    # dilation kernel with size of the a quarter of receptive field used to compute k
+    # as described in section 6 of main paper
+    kernel2 = np.ones(
+        (int(basesize / (4 * speed_scale)), int(basesize / (4 * speed_scale))), float
+    )
+
+    # Output resolution limit set by the whole_size_threshold and scale_threshold.
+    threshold = min(whole_size_threshold, scale_threshold * max(img.shape[:2]))
+
+    outputsize_scale = basesize / speed_scale
+    for p_size in range(
+        int(basesize / speed_scale),
+        int(threshold / speed_scale),
+        int(basesize / (2 * speed_scale)),
+    ):
+        grad_resized = resizewithpool(grad, p_size)
+        grad_resized = cv2.resize(grad_resized, (p_size, p_size), cv2.INTER_NEAREST)
+        grad_resized[grad_resized >= 0.5] = 1
+        grad_resized[grad_resized < 0.5] = 0
+
+        dilated = cv2.dilate(grad_resized, kernel, iterations=1)
+        meanvalue = (1 - dilated).mean()
+        if meanvalue > confidence:
+            break
+        else:
+            outputsize_scale = p_size
+
+    grad_region = cv2.dilate(grad_resized, kernel2, iterations=1)
+    patch_scale = grad_region.mean()
+
+    return int(outputsize_scale * speed_scale), patch_scale
+
+
+# Generate a double-input depth estimation
+def doubleestimate(img, size1, size2, pix2pixsize, model, net_type, pix2pixmodel):
+    # Generate the low resolution estimation
+    estimate1 = singleestimate(img, size1, model, net_type)
+    # Resize to the inference size of merge network.
+    estimate1 = cv2.resize(
+        estimate1, (pix2pixsize, pix2pixsize), interpolation=cv2.INTER_CUBIC
+    )
+
+    # Generate the high resolution estimation
+    estimate2 = singleestimate(img, size2, model, net_type)
+    # Resize to the inference size of merge network.
+    estimate2 = cv2.resize(
+        estimate2, (pix2pixsize, pix2pixsize), interpolation=cv2.INTER_CUBIC
+    )
+
+    # Inference on the merge model
+    pix2pixmodel.set_input(estimate1, estimate2)
+    pix2pixmodel.test()
+    visuals = pix2pixmodel.get_current_visuals()
+    prediction_mapped = visuals["fake_B"]
+    prediction_mapped = (prediction_mapped + 1) / 2
+    prediction_mapped = (prediction_mapped - torch.min(prediction_mapped)) / (
+        torch.max(prediction_mapped) - torch.min(prediction_mapped)
+    )
+    prediction_mapped = prediction_mapped.squeeze().cpu().numpy()
+
+    return prediction_mapped
+
+
+# Generate a single-input depth estimation
+def singleestimate(img, msize, model, net_type):
+    # if net_type == 0:
+    return estimateleres(img, model, msize, msize)
+    # else:
+    # 	return estimatemidasBoost(img, model, msize, msize)
+
+
+def applyGridpatch(blsize, stride, img, box):
+    # Extract a simple grid patch.
+    counter1 = 0
+    patch_bound_list = {}
+    for k in range(blsize, img.shape[1] - blsize, stride):
+        for j in range(blsize, img.shape[0] - blsize, stride):
+            patch_bound_list[str(counter1)] = {}
+            patchbounds = [
+                j - blsize,
+                k - blsize,
+                j - blsize + 2 * blsize,
+                k - blsize + 2 * blsize,
+            ]
+            patch_bound = [
+                box[0] + patchbounds[1],
+                box[1] + patchbounds[0],
+                patchbounds[3] - patchbounds[1],
+                patchbounds[2] - patchbounds[0],
+            ]
+            patch_bound_list[str(counter1)]["rect"] = patch_bound
+            patch_bound_list[str(counter1)]["size"] = patch_bound[2]
+            counter1 = counter1 + 1
+    return patch_bound_list
+
+
+# Generating local patches to perform the local refinement described in section 6 of the main paper.
+def generatepatchs(img, base_size):
+    # Compute the gradients as a proxy of the contextual cues.
+    img_gray = rgb2gray(img)
+    whole_grad = np.abs(cv2.Sobel(img_gray, cv2.CV_64F, 0, 1, ksize=3)) + np.abs(
+        cv2.Sobel(img_gray, cv2.CV_64F, 1, 0, ksize=3)
+    )
+
+    threshold = whole_grad[whole_grad > 0].mean()
+    whole_grad[whole_grad < threshold] = 0
+
+    # We use the integral image to speed-up the evaluation of the amount of gradients for each patch.
+    gf = whole_grad.sum() / len(whole_grad.reshape(-1))
+    grad_integral_image = cv2.integral(whole_grad)
+
+    # Variables are selected such that the initial patch size would be the receptive field size
+    # and the stride is set to 1/3 of the receptive field size.
+    blsize = int(round(base_size / 2))
+    stride = int(round(blsize * 0.75))
+
+    # Get initial Grid
+    patch_bound_list = applyGridpatch(blsize, stride, img, [0, 0, 0, 0])
+
+    # Refine initial Grid of patches by discarding the flat (in terms of gradients of the rgb image) ones. Refine
+    # each patch size to ensure that there will be enough depth cues for the network to generate a consistent depth map.
+    print("Selecting patches ...")
+    patch_bound_list = adaptiveselection(grad_integral_image, patch_bound_list, gf)
+
+    # Sort the patch list to make sure the merging operation will be done with the correct order: starting from biggest
+    # patch
+    patchset = sorted(
+        patch_bound_list.items(), key=lambda x: getitem(x[1], "size"), reverse=True
+    )
+    return patchset
+
+
+def getGF_fromintegral(integralimage, rect):
+    # Computes the gradient density of a given patch from the gradient integral image.
+    x1 = rect[1]
+    x2 = rect[1] + rect[3]
+    y1 = rect[0]
+    y2 = rect[0] + rect[2]
+    value = (
+        integralimage[x2, y2]
+        - integralimage[x1, y2]
+        - integralimage[x2, y1]
+        + integralimage[x1, y1]
+    )
+    return value
+
+
+# Adaptively select patches
+def adaptiveselection(integral_grad, patch_bound_list, gf):
+    patchlist = {}
+    count = 0
+    height, width = integral_grad.shape
+
+    search_step = int(32 / factor)
+
+    # Go through all patches
+    for c in range(len(patch_bound_list)):
+        # Get patch
+        bbox = patch_bound_list[str(c)]["rect"]
+
+        # Compute the amount of gradients present in the patch from the integral image.
+        cgf = getGF_fromintegral(integral_grad, bbox) / (bbox[2] * bbox[3])
+
+        # Check if patching is beneficial by comparing the gradient density of the patch to
+        # the gradient density of the whole image
+        if cgf >= gf:
+            bbox_test = bbox.copy()
+            patchlist[str(count)] = {}
+
+            # Enlarge each patch until the gradient density of the patch is equal
+            # to the whole image gradient density
+            while True:
+                bbox_test[0] = bbox_test[0] - int(search_step / 2)
+                bbox_test[1] = bbox_test[1] - int(search_step / 2)
+
+                bbox_test[2] = bbox_test[2] + search_step
+                bbox_test[3] = bbox_test[3] + search_step
+
+                # Check if we are still within the image
+                if (
+                    bbox_test[0] < 0
+                    or bbox_test[1] < 0
+                    or bbox_test[1] + bbox_test[3] >= height
+                    or bbox_test[0] + bbox_test[2] >= width
+                ):
+                    break
+
+                # Compare gradient density
+                cgf = getGF_fromintegral(integral_grad, bbox_test) / (
+                    bbox_test[2] * bbox_test[3]
+                )
+                if cgf < gf:
+                    break
+                bbox = bbox_test.copy()
+
+            # Add patch to selected patches
+            patchlist[str(count)]["rect"] = bbox
+            patchlist[str(count)]["size"] = bbox[2]
+            count = count + 1
+
+    # Return selected patches
+    return patchlist
+
+
+def impatch(image, rect):
+    # Extract the given patch pixels from a given image.
+    w1 = rect[0]
+    h1 = rect[1]
+    w2 = w1 + rect[2]
+    h2 = h1 + rect[3]
+    image_patch = image[h1:h2, w1:w2]
+    return image_patch
+
+
+class ImageandPatchs:
+    def __init__(self, root_dir, name, patchsinfo, rgb_image, scale=1):
+        self.root_dir = root_dir
+        self.patchsinfo = patchsinfo
+        self.name = name
+        self.patchs = patchsinfo
+        self.scale = scale
+
+        self.rgb_image = cv2.resize(
+            rgb_image,
+            (round(rgb_image.shape[1] * scale), round(rgb_image.shape[0] * scale)),
+            interpolation=cv2.INTER_CUBIC,
+        )
+
+        self.do_have_estimate = False
+        self.estimation_updated_image = None
+        self.estimation_base_image = None
+
+    def __len__(self):
+        return len(self.patchs)
+
+    def set_base_estimate(self, est):
+        self.estimation_base_image = est
+        if self.estimation_updated_image is not None:
+            self.do_have_estimate = True
+
+    def set_updated_estimate(self, est):
+        self.estimation_updated_image = est
+        if self.estimation_base_image is not None:
+            self.do_have_estimate = True
+
+    def __getitem__(self, index):
+        patch_id = int(self.patchs[index][0])
+        rect = np.array(self.patchs[index][1]["rect"])
+        msize = self.patchs[index][1]["size"]
+
+        ## applying scale to rect:
+        rect = np.round(rect * self.scale)
+        rect = rect.astype("int")
+        msize = round(msize * self.scale)
+
+        patch_rgb = impatch(self.rgb_image, rect)
+        if self.do_have_estimate:
+            patch_whole_estimate_base = impatch(self.estimation_base_image, rect)
+            patch_whole_estimate_updated = impatch(self.estimation_updated_image, rect)
+            return {
+                "patch_rgb": patch_rgb,
+                "patch_whole_estimate_base": patch_whole_estimate_base,
+                "patch_whole_estimate_updated": patch_whole_estimate_updated,
+                "rect": rect,
+                "size": msize,
+                "id": patch_id,
+            }
+        else:
+            return {"patch_rgb": patch_rgb, "rect": rect, "size": msize, "id": patch_id}
+
+    def print_options(self, opt):
+        """Print and save options
+
+        It will print both current options and default values(if different).
+        It will save options into a text file / [checkpoints_dir] / opt.txt
+        """
+        message = ""
+        message += "----------------- Options ---------------\n"
+        for k, v in sorted(vars(opt).items()):
+            comment = ""
+            default = self.parser.get_default(k)
+            if v != default:
+                comment = "\t[default: %s]" % str(default)
+            message += "{:>25}: {:<30}{}\n".format(str(k), str(v), comment)
+        message += "----------------- End -------------------"
+        print(message)
+
+        # save to the disk
+        """
+        expr_dir = os.path.join(opt.checkpoints_dir, opt.name)
+        util.mkdirs(expr_dir)
+        file_name = os.path.join(expr_dir, '{}_opt.txt'.format(opt.phase))
+        with open(file_name, 'wt') as opt_file:
+            opt_file.write(message)
+            opt_file.write('\n')
+        """
+
+    def parse(self):
+        """Parse our options, create checkpoints directory suffix, and set up gpu device."""
+        opt = self.gather_options()
+        opt.isTrain = self.isTrain  # train or test
+
+        # process opt.suffix
+        if opt.suffix:
+            suffix = ("_" + opt.suffix.format(**vars(opt))) if opt.suffix != "" else ""
+            opt.name = opt.name + suffix
+
+        # self.print_options(opt)
+
+        # set gpu ids
+        str_ids = opt.gpu_ids.split(",")
+        opt.gpu_ids = []
+        for str_id in str_ids:
+            id = int(str_id)
+            if id >= 0:
+                opt.gpu_ids.append(id)
+        # if len(opt.gpu_ids) > 0:
+        #    torch.cuda.set_device(opt.gpu_ids[0])
+
+        self.opt = opt
+        return self.opt
+
+
+def estimateboost(img, model, model_type, pix2pixmodel, max_res=512):
+    global whole_size_threshold
+
+    # get settings
+    if hasattr(opts, "depthmap_script_boost_rmax"):
+        whole_size_threshold = opts.depthmap_script_boost_rmax
+
+    if model_type == 0:  # leres
+        net_receptive_field_size = 448
+        patch_netsize = 2 * net_receptive_field_size
+    elif model_type == 1:  # dpt_beit_large_512
+        net_receptive_field_size = 512
+        patch_netsize = 2 * net_receptive_field_size
+    else:  # other midas
+        net_receptive_field_size = 384
+        patch_netsize = 2 * net_receptive_field_size
+
+    gc.collect()
+    devices.torch_gc()
+
+    # Generate mask used to smoothly blend the local pathc estimations to the base estimate.
+    # It is arbitrarily large to avoid artifacts during rescaling for each crop.
+    mask_org = generatemask((3000, 3000))
+    mask = mask_org.copy()
+
+    # Value x of R_x defined in the section 5 of the main paper.
+    r_threshold_value = 0.2
+    # if R0:
+    # r_threshold_value = 0
+
+    input_resolution = img.shape
+    scale_threshold = 3  # Allows up-scaling with a scale up to 3
+
+    # Find the best input resolution R-x. The resolution search described in section 5-double estimation of the main paper and section B of the
+    # supplementary material.
+    whole_image_optimal_size, patch_scale = calculateprocessingres(
+        img,
+        net_receptive_field_size,
+        r_threshold_value,
+        scale_threshold,
+        whole_size_threshold,
+    )
+
+    # print('wholeImage being processed in :', whole_image_optimal_size)
+
+    # Generate the base estimate using the double estimation.
+    whole_estimate = doubleestimate(
+        img,
+        net_receptive_field_size,
+        whole_image_optimal_size,
+        pix2pixsize,
+        model,
+        model_type,
+        pix2pixmodel,
+    )
+
+    # Compute the multiplier described in section 6 of the main paper to make sure our initial patch can select
+    # small high-density regions of the image.
+    global factor
+    factor = max(
+        min(1, 4 * patch_scale * whole_image_optimal_size / whole_size_threshold), 0.2
+    )
+    # print('Adjust factor is:', 1/factor)
+
+    # Check if Local boosting is beneficial.
+    if max_res < whole_image_optimal_size:
+        # print("No Local boosting. Specified Max Res is smaller than R20, Returning doubleestimate result")
+        return cv2.resize(
+            whole_estimate,
+            (input_resolution[1], input_resolution[0]),
+            interpolation=cv2.INTER_CUBIC,
+        )
+
+    # Compute the default target resolution.
+    if img.shape[0] > img.shape[1]:
+        a = 2 * whole_image_optimal_size
+        b = round(2 * whole_image_optimal_size * img.shape[1] / img.shape[0])
+    else:
+        a = round(2 * whole_image_optimal_size * img.shape[0] / img.shape[1])
+        b = 2 * whole_image_optimal_size
+    b = int(round(b / factor))
+    a = int(round(a / factor))
+
+    """
+    # recompute a, b and saturate to max res.
+    if max(a,b) > max_res:
+        print('Default Res is higher than max-res: Reducing final resolution')
+        if img.shape[0] > img.shape[1]:
+            a = max_res
+            b = round(max_res * img.shape[1] / img.shape[0])
+        else:
+            a = round(max_res * img.shape[0] / img.shape[1])
+            b = max_res
+        b = int(b)
+        a = int(a)
+    """
+
+    img = cv2.resize(img, (b, a), interpolation=cv2.INTER_CUBIC)
+
+    # Extract selected patches for local refinement
+    base_size = net_receptive_field_size * 2
+    patchset = generatepatchs(img, base_size)
+
+    # print('Target resolution: ', img.shape)
+
+    # Computing a scale in case user prompted to generate the results as the same resolution of the input.
+    # Notice that our method output resolution is independent of the input resolution and this parameter will only
+    # enable a scaling operation during the local patch merge implementation to generate results with the same resolution
+    # as the input.
+    """
+    if output_resolution == 1:
+        mergein_scale = input_resolution[0] / img.shape[0]
+        print('Dynamicly change merged-in resolution; scale:', mergein_scale)
+    else:
+        mergein_scale = 1
+    """
+    # always rescale to input res for now
+    mergein_scale = input_resolution[0] / img.shape[0]
+
+    imageandpatchs = ImageandPatchs("", "", patchset, img, mergein_scale)
+    whole_estimate_resized = cv2.resize(
+        whole_estimate,
+        (round(img.shape[1] * mergein_scale), round(img.shape[0] * mergein_scale)),
+        interpolation=cv2.INTER_CUBIC,
+    )
+    imageandpatchs.set_base_estimate(whole_estimate_resized.copy())
+    imageandpatchs.set_updated_estimate(whole_estimate_resized.copy())
+
+    print("Resulting depthmap resolution will be :", whole_estimate_resized.shape[:2])
+    print("Patches to process: " + str(len(imageandpatchs)))
+
+    # Enumerate through all patches, generate their estimations and refining the base estimate.
+    for patch_ind in range(len(imageandpatchs)):
+        # Get patch information
+        patch = imageandpatchs[patch_ind]  # patch object
+        patch_rgb = patch["patch_rgb"]  # rgb patch
+        patch_whole_estimate_base = patch[
+            "patch_whole_estimate_base"
+        ]  # corresponding patch from base
+        rect = patch["rect"]  # patch size and location
+        patch_id = patch["id"]  # patch ID
+        org_size = (
+            patch_whole_estimate_base.shape
+        )  # the original size from the unscaled input
+        print("\t Processing patch", patch_ind, "/", len(imageandpatchs) - 1, "|", rect)
+
+        # We apply double estimation for patches. The high resolution value is fixed to twice the receptive
+        # field size of the network for patches to accelerate the process.
+        patch_estimation = doubleestimate(
+            patch_rgb,
+            net_receptive_field_size,
+            patch_netsize,
+            pix2pixsize,
+            model,
+            model_type,
+            pix2pixmodel,
+        )
+        patch_estimation = cv2.resize(
+            patch_estimation, (pix2pixsize, pix2pixsize), interpolation=cv2.INTER_CUBIC
+        )
+        patch_whole_estimate_base = cv2.resize(
+            patch_whole_estimate_base,
+            (pix2pixsize, pix2pixsize),
+            interpolation=cv2.INTER_CUBIC,
+        )
+
+        # Merging the patch estimation into the base estimate using our merge network:
+        # We feed the patch estimation and the same region from the updated base estimate to the merge network
+        # to generate the target estimate for the corresponding region.
+        pix2pixmodel.set_input(patch_whole_estimate_base, patch_estimation)
+
+        # Run merging network
+        pix2pixmodel.test()
+        visuals = pix2pixmodel.get_current_visuals()
+
+        prediction_mapped = visuals["fake_B"]
+        prediction_mapped = (prediction_mapped + 1) / 2
+        prediction_mapped = prediction_mapped.squeeze().cpu().numpy()
+
+        mapped = prediction_mapped
+
+        # We use a simple linear polynomial to make sure the result of the merge network would match the values of
+        # base estimate
+        p_coef = np.polyfit(
+            mapped.reshape(-1), patch_whole_estimate_base.reshape(-1), deg=1
+        )
+        merged = np.polyval(p_coef, mapped.reshape(-1)).reshape(mapped.shape)
+
+        merged = cv2.resize(
+            merged, (org_size[1], org_size[0]), interpolation=cv2.INTER_CUBIC
+        )
+
+        # Get patch size and location
+        w1 = rect[0]
+        h1 = rect[1]
+        w2 = w1 + rect[2]
+        h2 = h1 + rect[3]
+
+        # To speed up the implementation, we only generate the Gaussian mask once with a sufficiently large size
+        # and resize it to our needed size while merging the patches.
+        if mask.shape != org_size:
+            mask = cv2.resize(
+                mask_org, (org_size[1], org_size[0]), interpolation=cv2.INTER_LINEAR
+            )
+
+        tobemergedto = imageandpatchs.estimation_updated_image
+
+        # Update the whole estimation:
+        # We use a simple Gaussian mask to blend the merged patch region with the base estimate to ensure seamless
+        # blending at the boundaries of the patch region.
+        tobemergedto[h1:h2, w1:w2] = np.multiply(
+            tobemergedto[h1:h2, w1:w2], 1 - mask
+        ) + np.multiply(merged, mask)
+        imageandpatchs.set_updated_estimate(tobemergedto)
+
+    # output
+    return cv2.resize(
+        imageandpatchs.estimation_updated_image,
+        (input_resolution[1], input_resolution[0]),
+        interpolation=cv2.INTER_CUBIC,
+    )

extensions-builtin/forge_legacy_preprocessors/annotator/leres/leres/multi_depth_model_woauxi.py

@@ -0,0 +1,35 @@
+from . import network_auxi as network
+from .net_tools import get_func
+import torch
+import torch.nn as nn
+from modules import devices
+
+
+class RelDepthModel(nn.Module):
+    def __init__(self, backbone="resnet50"):
+        super(RelDepthModel, self).__init__()
+        if backbone == "resnet50":
+            encoder = "resnet50_stride32"
+        elif backbone == "resnext101":
+            encoder = "resnext101_stride32x8d"
+        self.depth_model = DepthModel(encoder)
+
+    def inference(self, rgb):
+        with torch.no_grad():
+            input = rgb.to(self.depth_model.device)
+            depth = self.depth_model(input)
+            # pred_depth_out = depth - depth.min() + 0.01
+            return depth  # pred_depth_out
+
+
+class DepthModel(nn.Module):
+    def __init__(self, encoder):
+        super(DepthModel, self).__init__()
+        backbone = network.__name__.split(".")[-1] + "." + encoder
+        self.encoder_modules = get_func(backbone)()
+        self.decoder_modules = network.Decoder()
+
+    def forward(self, x):
+        lateral_out = self.encoder_modules(x)
+        out_logit = self.decoder_modules(lateral_out)
+        return out_logit

extensions-builtin/forge_legacy_preprocessors/annotator/leres/leres/net_tools.py

@@ -0,0 +1,60 @@
+import importlib
+import torch
+import os
+from collections import OrderedDict
+
+
+def get_func(func_name):
+    """Helper to return a function object by name. func_name must identify a
+    function in this module or the path to a function relative to the base
+    'modeling' module.
+    """
+    if func_name == "":
+        return None
+    try:
+        parts = func_name.split(".")
+        # Refers to a function in this module
+        if len(parts) == 1:
+            return globals()[parts[0]]
+        # Otherwise, assume we're referencing a module under modeling
+        module_name = "annotator.leres.leres." + ".".join(parts[:-1])
+        module = importlib.import_module(module_name)
+        return getattr(module, parts[-1])
+    except Exception:
+        print("Failed to f1ind function: %s", func_name)
+        raise
+
+
+def load_ckpt(args, depth_model, shift_model, focal_model):
+    """
+    Load checkpoint.
+    """
+    if os.path.isfile(args.load_ckpt):
+        print("loading checkpoint %s" % args.load_ckpt)
+        checkpoint = torch.load(args.load_ckpt)
+        if shift_model is not None:
+            shift_model.load_state_dict(
+                strip_prefix_if_present(checkpoint["shift_model"], "module."),
+                strict=True,
+            )
+        if focal_model is not None:
+            focal_model.load_state_dict(
+                strip_prefix_if_present(checkpoint["focal_model"], "module."),
+                strict=True,
+            )
+        depth_model.load_state_dict(
+            strip_prefix_if_present(checkpoint["depth_model"], "module."), strict=True
+        )
+        del checkpoint
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+
+def strip_prefix_if_present(state_dict, prefix):
+    keys = sorted(state_dict.keys())
+    if not all(key.startswith(prefix) for key in keys):
+        return state_dict
+    stripped_state_dict = OrderedDict()
+    for key, value in state_dict.items():
+        stripped_state_dict[key.replace(prefix, "")] = value
+    return stripped_state_dict

extensions-builtin/forge_legacy_preprocessors/annotator/leres/leres/network_auxi.py

@@ -0,0 +1,509 @@
+import torch
+import torch.nn as nn
+import torch.nn.init as init
+
+from . import Resnet, Resnext_torch
+
+
+def resnet50_stride32():
+    return DepthNet(backbone="resnet", depth=50, upfactors=[2, 2, 2, 2])
+
+
+def resnext101_stride32x8d():
+    return DepthNet(backbone="resnext101_32x8d", depth=101, upfactors=[2, 2, 2, 2])
+
+
+class Decoder(nn.Module):
+    def __init__(self):
+        super(Decoder, self).__init__()
+        self.inchannels = [256, 512, 1024, 2048]
+        self.midchannels = [256, 256, 256, 512]
+        self.upfactors = [2, 2, 2, 2]
+        self.outchannels = 1
+
+        self.conv = FTB(inchannels=self.inchannels[3], midchannels=self.midchannels[3])
+        self.conv1 = nn.Conv2d(
+            in_channels=self.midchannels[3],
+            out_channels=self.midchannels[2],
+            kernel_size=3,
+            padding=1,
+            stride=1,
+            bias=True,
+        )
+        self.upsample = nn.Upsample(
+            scale_factor=self.upfactors[3], mode="bilinear", align_corners=True
+        )
+
+        self.ffm2 = FFM(
+            inchannels=self.inchannels[2],
+            midchannels=self.midchannels[2],
+            outchannels=self.midchannels[2],
+            upfactor=self.upfactors[2],
+        )
+        self.ffm1 = FFM(
+            inchannels=self.inchannels[1],
+            midchannels=self.midchannels[1],
+            outchannels=self.midchannels[1],
+            upfactor=self.upfactors[1],
+        )
+        self.ffm0 = FFM(
+            inchannels=self.inchannels[0],
+            midchannels=self.midchannels[0],
+            outchannels=self.midchannels[0],
+            upfactor=self.upfactors[0],
+        )
+
+        self.outconv = AO(
+            inchannels=self.midchannels[0], outchannels=self.outchannels, upfactor=2
+        )
+        self._init_params()
+
+    def _init_params(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                init.normal_(m.weight, std=0.01)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+            elif isinstance(m, nn.ConvTranspose2d):
+                init.normal_(m.weight, std=0.01)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):  # NN.BatchNorm2d
+                init.constant_(m.weight, 1)
+                init.constant_(m.bias, 0)
+            elif isinstance(m, nn.Linear):
+                init.normal_(m.weight, std=0.01)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+
+    def forward(self, features):
+        x_32x = self.conv(features[3])  # 1/32
+        x_32 = self.conv1(x_32x)
+        x_16 = self.upsample(x_32)  # 1/16
+
+        x_8 = self.ffm2(features[2], x_16)  # 1/8
+        x_4 = self.ffm1(features[1], x_8)  # 1/4
+        x_2 = self.ffm0(features[0], x_4)  # 1/2
+        # -----------------------------------------
+        x = self.outconv(x_2)  # original size
+        return x
+
+
+class DepthNet(nn.Module):
+    __factory = {
+        18: Resnet.resnet18,
+        34: Resnet.resnet34,
+        50: Resnet.resnet50,
+        101: Resnet.resnet101,
+        152: Resnet.resnet152,
+    }
+
+    def __init__(self, backbone="resnet", depth=50, upfactors=[2, 2, 2, 2]):
+        super(DepthNet, self).__init__()
+        self.backbone = backbone
+        self.depth = depth
+        self.pretrained = False
+        self.inchannels = [256, 512, 1024, 2048]
+        self.midchannels = [256, 256, 256, 512]
+        self.upfactors = upfactors
+        self.outchannels = 1
+
+        # Build model
+        if self.backbone == "resnet":
+            if self.depth not in DepthNet.__factory:
+                raise KeyError("Unsupported depth:", self.depth)
+            self.encoder = DepthNet.__factory[depth](pretrained=self.pretrained)
+        elif self.backbone == "resnext101_32x8d":
+            self.encoder = Resnext_torch.resnext101_32x8d(pretrained=self.pretrained)
+        else:
+            self.encoder = Resnext_torch.resnext101(pretrained=self.pretrained)
+
+    def forward(self, x):
+        x = self.encoder(x)  # 1/32, 1/16, 1/8, 1/4
+        return x
+
+
+class FTB(nn.Module):
+    def __init__(self, inchannels, midchannels=512):
+        super(FTB, self).__init__()
+        self.in1 = inchannels
+        self.mid = midchannels
+        self.conv1 = nn.Conv2d(
+            in_channels=self.in1,
+            out_channels=self.mid,
+            kernel_size=3,
+            padding=1,
+            stride=1,
+            bias=True,
+        )
+        # NN.BatchNorm2d
+        self.conv_branch = nn.Sequential(
+            nn.ReLU(inplace=True),
+            nn.Conv2d(
+                in_channels=self.mid,
+                out_channels=self.mid,
+                kernel_size=3,
+                padding=1,
+                stride=1,
+                bias=True,
+            ),
+            nn.BatchNorm2d(num_features=self.mid),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(
+                in_channels=self.mid,
+                out_channels=self.mid,
+                kernel_size=3,
+                padding=1,
+                stride=1,
+                bias=True,
+            ),
+        )
+        self.relu = nn.ReLU(inplace=True)
+
+        self.init_params()
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = x + self.conv_branch(x)
+        x = self.relu(x)
+
+        return x
+
+    def init_params(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                init.normal_(m.weight, std=0.01)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+            elif isinstance(m, nn.ConvTranspose2d):
+                # init.kaiming_normal_(m.weight, mode='fan_out')
+                init.normal_(m.weight, std=0.01)
+                # init.xavier_normal_(m.weight)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):  # NN.BatchNorm2d
+                init.constant_(m.weight, 1)
+                init.constant_(m.bias, 0)
+            elif isinstance(m, nn.Linear):
+                init.normal_(m.weight, std=0.01)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+
+
+class ATA(nn.Module):
+    def __init__(self, inchannels, reduction=8):
+        super(ATA, self).__init__()
+        self.inchannels = inchannels
+        self.avg_pool = nn.AdaptiveAvgPool2d(1)
+        self.fc = nn.Sequential(
+            nn.Linear(self.inchannels * 2, self.inchannels // reduction),
+            nn.ReLU(inplace=True),
+            nn.Linear(self.inchannels // reduction, self.inchannels),
+            nn.Sigmoid(),
+        )
+        self.init_params()
+
+    def forward(self, low_x, high_x):
+        n, c, _, _ = low_x.size()
+        x = torch.cat([low_x, high_x], 1)
+        x = self.avg_pool(x)
+        x = x.view(n, -1)
+        x = self.fc(x).view(n, c, 1, 1)
+        x = low_x * x + high_x
+
+        return x
+
+    def init_params(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                # init.kaiming_normal_(m.weight, mode='fan_out')
+                # init.normal(m.weight, std=0.01)
+                init.xavier_normal_(m.weight)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+            elif isinstance(m, nn.ConvTranspose2d):
+                # init.kaiming_normal_(m.weight, mode='fan_out')
+                # init.normal_(m.weight, std=0.01)
+                init.xavier_normal_(m.weight)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):  # NN.BatchNorm2d
+                init.constant_(m.weight, 1)
+                init.constant_(m.bias, 0)
+            elif isinstance(m, nn.Linear):
+                init.normal_(m.weight, std=0.01)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+
+
+class FFM(nn.Module):
+    def __init__(self, inchannels, midchannels, outchannels, upfactor=2):
+        super(FFM, self).__init__()
+        self.inchannels = inchannels
+        self.midchannels = midchannels
+        self.outchannels = outchannels
+        self.upfactor = upfactor
+
+        self.ftb1 = FTB(inchannels=self.inchannels, midchannels=self.midchannels)
+        # self.ata = ATA(inchannels = self.midchannels)
+        self.ftb2 = FTB(inchannels=self.midchannels, midchannels=self.outchannels)
+
+        self.upsample = nn.Upsample(
+            scale_factor=self.upfactor, mode="bilinear", align_corners=True
+        )
+
+        self.init_params()
+
+    def forward(self, low_x, high_x):
+        x = self.ftb1(low_x)
+        x = x + high_x
+        x = self.ftb2(x)
+        x = self.upsample(x)
+
+        return x
+
+    def init_params(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                # init.kaiming_normal_(m.weight, mode='fan_out')
+                init.normal_(m.weight, std=0.01)
+                # init.xavier_normal_(m.weight)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+            elif isinstance(m, nn.ConvTranspose2d):
+                # init.kaiming_normal_(m.weight, mode='fan_out')
+                init.normal_(m.weight, std=0.01)
+                # init.xavier_normal_(m.weight)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):  # NN.Batchnorm2d
+                init.constant_(m.weight, 1)
+                init.constant_(m.bias, 0)
+            elif isinstance(m, nn.Linear):
+                init.normal_(m.weight, std=0.01)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+
+
+class AO(nn.Module):
+    # Adaptive output module
+    def __init__(self, inchannels, outchannels, upfactor=2):
+        super(AO, self).__init__()
+        self.inchannels = inchannels
+        self.outchannels = outchannels
+        self.upfactor = upfactor
+
+        self.adapt_conv = nn.Sequential(
+            nn.Conv2d(
+                in_channels=self.inchannels,
+                out_channels=self.inchannels // 2,
+                kernel_size=3,
+                padding=1,
+                stride=1,
+                bias=True,
+            ),
+            nn.BatchNorm2d(num_features=self.inchannels // 2),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(
+                in_channels=self.inchannels // 2,
+                out_channels=self.outchannels,
+                kernel_size=3,
+                padding=1,
+                stride=1,
+                bias=True,
+            ),
+            nn.Upsample(
+                scale_factor=self.upfactor, mode="bilinear", align_corners=True
+            ),
+        )
+
+        self.init_params()
+
+    def forward(self, x):
+        x = self.adapt_conv(x)
+        return x
+
+    def init_params(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                # init.kaiming_normal_(m.weight, mode='fan_out')
+                init.normal_(m.weight, std=0.01)
+                # init.xavier_normal_(m.weight)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+            elif isinstance(m, nn.ConvTranspose2d):
+                # init.kaiming_normal_(m.weight, mode='fan_out')
+                init.normal_(m.weight, std=0.01)
+                # init.xavier_normal_(m.weight)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):  # NN.Batchnorm2d
+                init.constant_(m.weight, 1)
+                init.constant_(m.bias, 0)
+            elif isinstance(m, nn.Linear):
+                init.normal_(m.weight, std=0.01)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+
+
+# ==============================================================================================================
+
+
+class ResidualConv(nn.Module):
+    def __init__(self, inchannels):
+        super(ResidualConv, self).__init__()
+        # NN.BatchNorm2d
+        self.conv = nn.Sequential(
+            # nn.BatchNorm2d(num_features=inchannels),
+            nn.ReLU(inplace=False),
+            # nn.Conv2d(in_channels=inchannels, out_channels=inchannels, kernel_size=3, padding=1, stride=1, groups=inchannels,bias=True),
+            # nn.Conv2d(in_channels=inchannels, out_channels=inchannels, kernel_size=1, padding=0, stride=1, groups=1,bias=True)
+            nn.Conv2d(
+                in_channels=inchannels,
+                out_channels=inchannels / 2,
+                kernel_size=3,
+                padding=1,
+                stride=1,
+                bias=False,
+            ),
+            nn.BatchNorm2d(num_features=inchannels / 2),
+            nn.ReLU(inplace=False),
+            nn.Conv2d(
+                in_channels=inchannels / 2,
+                out_channels=inchannels,
+                kernel_size=3,
+                padding=1,
+                stride=1,
+                bias=False,
+            ),
+        )
+        self.init_params()
+
+    def forward(self, x):
+        x = self.conv(x) + x
+        return x
+
+    def init_params(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                # init.kaiming_normal_(m.weight, mode='fan_out')
+                init.normal_(m.weight, std=0.01)
+                # init.xavier_normal_(m.weight)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+            elif isinstance(m, nn.ConvTranspose2d):
+                # init.kaiming_normal_(m.weight, mode='fan_out')
+                init.normal_(m.weight, std=0.01)
+                # init.xavier_normal_(m.weight)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):  # NN.BatchNorm2d
+                init.constant_(m.weight, 1)
+                init.constant_(m.bias, 0)
+            elif isinstance(m, nn.Linear):
+                init.normal_(m.weight, std=0.01)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+
+
+class FeatureFusion(nn.Module):
+    def __init__(self, inchannels, outchannels):
+        super(FeatureFusion, self).__init__()
+        self.conv = ResidualConv(inchannels=inchannels)
+        # NN.BatchNorm2d
+        self.up = nn.Sequential(
+            ResidualConv(inchannels=inchannels),
+            nn.ConvTranspose2d(
+                in_channels=inchannels,
+                out_channels=outchannels,
+                kernel_size=3,
+                stride=2,
+                padding=1,
+                output_padding=1,
+            ),
+            nn.BatchNorm2d(num_features=outchannels),
+            nn.ReLU(inplace=True),
+        )
+
+    def forward(self, lowfeat, highfeat):
+        return self.up(highfeat + self.conv(lowfeat))
+
+    def init_params(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                # init.kaiming_normal_(m.weight, mode='fan_out')
+                init.normal_(m.weight, std=0.01)
+                # init.xavier_normal_(m.weight)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+            elif isinstance(m, nn.ConvTranspose2d):
+                # init.kaiming_normal_(m.weight, mode='fan_out')
+                init.normal_(m.weight, std=0.01)
+                # init.xavier_normal_(m.weight)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):  # NN.BatchNorm2d
+                init.constant_(m.weight, 1)
+                init.constant_(m.bias, 0)
+            elif isinstance(m, nn.Linear):
+                init.normal_(m.weight, std=0.01)
+                if m.bias is not None:
+                    init.constant_(m.bias, 0)
+
+
+class SenceUnderstand(nn.Module):
+    def __init__(self, channels):
+        super(SenceUnderstand, self).__init__()
+        self.channels = channels
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+        )
+        self.pool = nn.AdaptiveAvgPool2d(8)
+        self.fc = nn.Sequential(
+            nn.Linear(512 * 8 * 8, self.channels), nn.ReLU(inplace=True)
+        )
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(
+                in_channels=self.channels,
+                out_channels=self.channels,
+                kernel_size=1,
+                padding=0,
+            ),
+            nn.ReLU(inplace=True),
+        )
+        self.initial_params()
+
+    def forward(self, x):
+        n, c, h, w = x.size()
+        x = self.conv1(x)
+        x = self.pool(x)
+        x = x.view(n, -1)
+        x = self.fc(x)
+        x = x.view(n, self.channels, 1, 1)
+        x = self.conv2(x)
+        x = x.repeat(1, 1, h, w)
+        return x
+
+    def initial_params(self, dev=0.01):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                # print torch.sum(m.weight)
+                m.weight.data.normal_(0, dev)
+                if m.bias is not None:
+                    m.bias.data.fill_(0)
+            elif isinstance(m, nn.ConvTranspose2d):
+                # print torch.sum(m.weight)
+                m.weight.data.normal_(0, dev)
+                if m.bias is not None:
+                    m.bias.data.fill_(0)
+            elif isinstance(m, nn.Linear):
+                m.weight.data.normal_(0, dev)
+
+
+if __name__ == "__main__":
+    net = DepthNet(depth=50, pretrained=True)
+    print(net)
+    inputs = torch.ones(4, 3, 128, 128)
+    out = net(inputs)
+    print(out.size())

extensions-builtin/forge_legacy_preprocessors/annotator/leres/pix2pix/LICENSE

@@ -0,0 +1,19 @@
+https://github.com/compphoto/BoostingMonocularDepth
+
+Copyright 2021, Seyed Mahdi Hosseini Miangoleh, Sebastian Dille, Computational Photography Laboratory. All rights reserved.
+
+This software is for academic use only. A redistribution of this 
+software, with or  without modifications, has to be for academic 
+use only, while giving the appropriate credit to the original 
+authors of the software. The methods implemented as a part of 
+this software may be covered under patents or patent applications.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

extensions-builtin/forge_legacy_preprocessors/annotator/leres/pix2pix/models/__init__.py

@@ -0,0 +1,69 @@
+"""This package contains modules related to objective functions, optimizations, and network architectures.
+
+To add a custom model class called 'dummy', you need to add a file called 'dummy_model.py' and define a subclass DummyModel inherited from BaseModel.
+You need to implement the following five functions:
+    -- <__init__>:                      initialize the class; first call BaseModel.__init__(self, opt).
+    -- <set_input>:                     unpack data from dataset and apply preprocessing.
+    -- <forward>:                       produce intermediate results.
+    -- <optimize_parameters>:           calculate loss, gradients, and update network weights.
+    -- <modify_commandline_options>:    (optionally) add model-specific options and set default options.
+
+In the function <__init__>, you need to define four lists:
+    -- self.loss_names (str list):          specify the training losses that you want to plot and save.
+    -- self.model_names (str list):         define networks used in our training.
+    -- self.visual_names (str list):        specify the images that you want to display and save.
+    -- self.optimizers (optimizer list):    define and initialize optimizers. You can define one optimizer for each network. If two networks are updated at the same time, you can use itertools.chain to group them. See cycle_gan_model.py for an usage.
+
+Now you can use the model class by specifying flag '--model dummy'.
+See our template model class 'template_model.py' for more details.
+"""
+
+import importlib
+from .base_model import BaseModel
+
+
+def find_model_using_name(model_name):
+    """Import the module "models/[model_name]_model.py".
+
+    In the file, the class called DatasetNameModel() will
+    be instantiated. It has to be a subclass of BaseModel,
+    and it is case-insensitive.
+    """
+    model_filename = "annotator.leres.pix2pix.models." + model_name + "_model"
+    modellib = importlib.import_module(model_filename)
+    model = None
+    target_model_name = model_name.replace("_", "") + "model"
+    for name, cls in modellib.__dict__.items():
+        if name.lower() == target_model_name.lower() and issubclass(cls, BaseModel):
+            model = cls
+
+    if model is None:
+        print(
+            "In %s.py, there should be a subclass of BaseModel with class name that matches %s in lowercase."
+            % (model_filename, target_model_name)
+        )
+        exit(0)
+
+    return model
+
+
+def get_option_setter(model_name):
+    """Return the static method <modify_commandline_options> of the model class."""
+    model_class = find_model_using_name(model_name)
+    return model_class.modify_commandline_options
+
+
+def create_model(opt):
+    """Create a model given the option.
+
+    This function warps the class CustomDatasetDataLoader.
+    This is the main interface between this package and 'train.py'/'test.py'
+
+    Example:
+        >>> from models import create_model
+        >>> model = create_model(opt)
+    """
+    model = find_model_using_name(opt.model)
+    instance = model(opt)
+    print("model [%s] was created" % type(instance).__name__)
+    return instance

extensions-builtin/forge_legacy_preprocessors/annotator/leres/pix2pix/models/base_model.py

@@ -0,0 +1,263 @@
+import os
+import torch, gc
+from modules import devices
+from collections import OrderedDict
+from abc import ABC, abstractmethod
+from . import networks
+
+
+class BaseModel(ABC):
+    """This class is an abstract base class (ABC) for models.
+    To create a subclass, you need to implement the following five functions:
+        -- <__init__>:                      initialize the class; first call BaseModel.__init__(self, opt).
+        -- <set_input>:                     unpack data from dataset and apply preprocessing.
+        -- <forward>:                       produce intermediate results.
+        -- <optimize_parameters>:           calculate losses, gradients, and update network weights.
+        -- <modify_commandline_options>:    (optionally) add model-specific options and set default options.
+    """
+
+    def __init__(self, opt):
+        """Initialize the BaseModel class.
+
+        Parameters:
+            opt (Option class)-- stores all the experiment flags; needs to be a subclass of BaseOptions
+
+        When creating your custom class, you need to implement your own initialization.
+        In this function, you should first call <BaseModel.__init__(self, opt)>
+        Then, you need to define four lists:
+            -- self.loss_names (str list):          specify the training losses that you want to plot and save.
+            -- self.model_names (str list):         define networks used in our training.
+            -- self.visual_names (str list):        specify the images that you want to display and save.
+            -- self.optimizers (optimizer list):    define and initialize optimizers. You can define one optimizer for each network. If two networks are updated at the same time, you can use itertools.chain to group them. See cycle_gan_model.py for an example.
+        """
+        self.opt = opt
+        self.gpu_ids = opt.gpu_ids
+        self.isTrain = opt.isTrain
+        self.device = (
+            torch.device("cuda:{}".format(self.gpu_ids[0]))
+            if self.gpu_ids
+            else torch.device("cpu")
+        )  # get device name: CPU or GPU
+        self.save_dir = os.path.join(
+            opt.checkpoints_dir, opt.name
+        )  # save all the checkpoints to save_dir
+        if (
+            opt.preprocess != "scale_width"
+        ):  # with [scale_width], input images might have different sizes, which hurts the performance of cudnn.benchmark.
+            torch.backends.cudnn.benchmark = True
+        self.loss_names = []
+        self.model_names = []
+        self.visual_names = []
+        self.optimizers = []
+        self.image_paths = []
+        self.metric = 0  # used for learning rate policy 'plateau'
+
+    @staticmethod
+    def modify_commandline_options(parser, is_train):
+        """Add new model-specific options, and rewrite default values for existing options.
+
+        Parameters:
+            parser          -- original option parser
+            is_train (bool) -- whether training phase or test phase. You can use this flag to add training-specific or test-specific options.
+
+        Returns:
+            the modified parser.
+        """
+        return parser
+
+    @abstractmethod
+    def set_input(self, input):
+        """Unpack input data from the dataloader and perform necessary pre-processing steps.
+
+        Parameters:
+            input (dict): includes the data itself and its metadata information.
+        """
+        pass
+
+    @abstractmethod
+    def forward(self):
+        """Run forward pass; called by both functions <optimize_parameters> and <test>."""
+        pass
+
+    @abstractmethod
+    def optimize_parameters(self):
+        """Calculate losses, gradients, and update network weights; called in every training iteration"""
+        pass
+
+    def setup(self, opt):
+        """Load and print networks; create schedulers
+
+        Parameters:
+            opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions
+        """
+        if self.isTrain:
+            self.schedulers = [
+                networks.get_scheduler(optimizer, opt) for optimizer in self.optimizers
+            ]
+        if not self.isTrain or opt.continue_train:
+            load_suffix = "iter_%d" % opt.load_iter if opt.load_iter > 0 else opt.epoch
+            self.load_networks(load_suffix)
+        self.print_networks(opt.verbose)
+
+    def eval(self):
+        """Make models eval mode during test time"""
+        for name in self.model_names:
+            if isinstance(name, str):
+                net = getattr(self, "net" + name)
+                net.eval()
+
+    def test(self):
+        """Forward function used in test time.
+
+        This function wraps <forward> function in no_grad() so we don't save intermediate steps for backprop
+        It also calls <compute_visuals> to produce additional visualization results
+        """
+        with torch.no_grad():
+            self.forward()
+            self.compute_visuals()
+
+    def compute_visuals(self):
+        """Calculate additional output images for visdom and HTML visualization"""
+        pass
+
+    def get_image_paths(self):
+        """Return image paths that are used to load current data"""
+        return self.image_paths
+
+    def update_learning_rate(self):
+        """Update learning rates for all the networks; called at the end of every epoch"""
+        old_lr = self.optimizers[0].param_groups[0]["lr"]
+        for scheduler in self.schedulers:
+            if self.opt.lr_policy == "plateau":
+                scheduler.step(self.metric)
+            else:
+                scheduler.step()
+
+        lr = self.optimizers[0].param_groups[0]["lr"]
+        print("learning rate %.7f -> %.7f" % (old_lr, lr))
+
+    def get_current_visuals(self):
+        """Return visualization images. train.py will display these images with visdom, and save the images to a HTML"""
+        visual_ret = OrderedDict()
+        for name in self.visual_names:
+            if isinstance(name, str):
+                visual_ret[name] = getattr(self, name)
+        return visual_ret
+
+    def get_current_losses(self):
+        """Return traning losses / errors. train.py will print out these errors on console, and save them to a file"""
+        errors_ret = OrderedDict()
+        for name in self.loss_names:
+            if isinstance(name, str):
+                errors_ret[name] = float(
+                    getattr(self, "loss_" + name)
+                )  # float(...) works for both scalar tensor and float number
+        return errors_ret
+
+    def save_networks(self, epoch):
+        """Save all the networks to the disk.
+
+        Parameters:
+            epoch (int) -- current epoch; used in the file name '%s_net_%s.pth' % (epoch, name)
+        """
+        for name in self.model_names:
+            if isinstance(name, str):
+                save_filename = "%s_net_%s.pth" % (epoch, name)
+                save_path = os.path.join(self.save_dir, save_filename)
+                net = getattr(self, "net" + name)
+
+                if len(self.gpu_ids) > 0 and torch.cuda.is_available():
+                    torch.save(net.module.cpu().state_dict(), save_path)
+                    net.cuda(self.gpu_ids[0])
+                else:
+                    torch.save(net.cpu().state_dict(), save_path)
+
+    def unload_network(self, name):
+        """Unload network and gc."""
+        if isinstance(name, str):
+            net = getattr(self, "net" + name)
+            del net
+            gc.collect()
+            devices.torch_gc()
+            return None
+
+    def __patch_instance_norm_state_dict(self, state_dict, module, keys, i=0):
+        """Fix InstanceNorm checkpoints incompatibility (prior to 0.4)"""
+        key = keys[i]
+        if i + 1 == len(keys):  # at the end, pointing to a parameter/buffer
+            if module.__class__.__name__.startswith("InstanceNorm") and (
+                key == "running_mean" or key == "running_var"
+            ):
+                if getattr(module, key) is None:
+                    state_dict.pop(".".join(keys))
+            if module.__class__.__name__.startswith("InstanceNorm") and (
+                key == "num_batches_tracked"
+            ):
+                state_dict.pop(".".join(keys))
+        else:
+            self.__patch_instance_norm_state_dict(
+                state_dict, getattr(module, key), keys, i + 1
+            )
+
+    def load_networks(self, epoch):
+        """Load all the networks from the disk.
+
+        Parameters:
+            epoch (int) -- current epoch; used in the file name '%s_net_%s.pth' % (epoch, name)
+        """
+        for name in self.model_names:
+            if isinstance(name, str):
+                load_filename = "%s_net_%s.pth" % (epoch, name)
+                load_path = os.path.join(self.save_dir, load_filename)
+                net = getattr(self, "net" + name)
+                if isinstance(net, torch.nn.DataParallel):
+                    net = net.module
+                # print('Loading depth boost model from %s' % load_path)
+                # if you are using PyTorch newer than 0.4 (e.g., built from
+                # GitHub source), you can remove str() on self.device
+                state_dict = torch.load(load_path, map_location=str(self.device))
+                if hasattr(state_dict, "_metadata"):
+                    del state_dict._metadata
+
+                # patch InstanceNorm checkpoints prior to 0.4
+                for key in list(
+                    state_dict.keys()
+                ):  # need to copy keys here because we mutate in loop
+                    self.__patch_instance_norm_state_dict(
+                        state_dict, net, key.split(".")
+                    )
+                net.load_state_dict(state_dict)
+
+    def print_networks(self, verbose):
+        """Print the total number of parameters in the network and (if verbose) network architecture
+
+        Parameters:
+            verbose (bool) -- if verbose: print the network architecture
+        """
+        print("---------- Networks initialized -------------")
+        for name in self.model_names:
+            if isinstance(name, str):
+                net = getattr(self, "net" + name)
+                num_params = 0
+                for param in net.parameters():
+                    num_params += param.numel()
+                if verbose:
+                    print(net)
+                print(
+                    "[Network %s] Total number of parameters : %.3f M"
+                    % (name, num_params / 1e6)
+                )
+        print("-----------------------------------------------")
+
+    def set_requires_grad(self, nets, requires_grad=False):
+        """Set requies_grad=Fasle for all the networks to avoid unnecessary computations
+        Parameters:
+            nets (network list)   -- a list of networks
+            requires_grad (bool)  -- whether the networks require gradients or not
+        """
+        if not isinstance(nets, list):
+            nets = [nets]
+        for net in nets:
+            if net is not None:
+                for param in net.parameters():
+                    param.requires_grad = requires_grad

extensions-builtin/forge_legacy_preprocessors/annotator/leres/pix2pix/models/base_model_hg.py

@@ -0,0 +1,59 @@
+import os
+import torch
+
+
+class BaseModelHG:
+    def name(self):
+        return "BaseModel"
+
+    def initialize(self, opt):
+        self.opt = opt
+        self.gpu_ids = opt.gpu_ids
+        self.isTrain = opt.isTrain
+        self.Tensor = torch.cuda.FloatTensor if self.gpu_ids else torch.Tensor
+        self.save_dir = os.path.join(opt.checkpoints_dir, opt.name)
+
+    def set_input(self, input):
+        self.input = input
+
+    def forward(self):
+        pass
+
+    # used in test time, no backprop
+    def test(self):
+        pass
+
+    def get_image_paths(self):
+        pass
+
+    def optimize_parameters(self):
+        pass
+
+    def get_current_visuals(self):
+        return self.input
+
+    def get_current_errors(self):
+        return {}
+
+    def save(self, label):
+        pass
+
+    # helper saving function that can be used by subclasses
+    def save_network(self, network, network_label, epoch_label, gpu_ids):
+        save_filename = "_%s_net_%s.pth" % (epoch_label, network_label)
+        save_path = os.path.join(self.save_dir, save_filename)
+        torch.save(network.cpu().state_dict(), save_path)
+        if len(gpu_ids) and torch.cuda.is_available():
+            network.cuda(device_id=gpu_ids[0])
+
+    # helper loading function that can be used by subclasses
+    def load_network(self, network, network_label, epoch_label):
+        save_filename = "%s_net_%s.pth" % (epoch_label, network_label)
+        save_path = os.path.join(self.save_dir, save_filename)
+        print(save_path)
+        model = torch.load(save_path)
+        return model
+        # network.load_state_dict(torch.load(save_path))
+
+    def update_learning_rate():
+        pass