Upload 10 files

regional-prompter-main/LICENCE

@@ -0,0 +1,663 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+                       
+                      Copyright (c) 2023 hako-mikan
+
+ 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
+
+            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 Affero 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 Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero 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 your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  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 AGPL, see
+<https://www.gnu.org/licenses/>.

regional-prompter-main/README.JP.md

@@ -0,0 +1,295 @@
+# Regional Prompter
+![top](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/top.jpg)
+- custom script for [AUTOMATIC1111's stable-diffusion-webui](https://github.com/AUTOMATIC1111/stable-diffusion-webui) 
+- Different prompts can be specified for different regions
+
+- [AUTOMATIC1111's stable-diffusion-webui](https://github.com/AUTOMATIC1111/stable-diffusion-webui) 用のスクリプトです
+- 垂直/平行方向に分割された領域ごとに異なるプロンプトを指定できます
+
+## Language control / 言語制御
+ENGLISH: [![en](https://img.shields.io/badge/lang-en-red.svg)](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/main/README.md)
+
+## 更新情報
+- [APIを通しての利用について](#apiを通した利用方法)
+- プロンプトによる領域指定の[チュートリアル](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/main/prompt_ja.md)
+- 新機能 : [インペイントによる領域指定](#inpaint) (thanks [Symbiomatrix](https://github.com/Symbiomatrix))
+- 新機能 : [プロンプトによる領域指定](#divprompt) 
+
+
+[Symbiomatrix](https://github.com/Symbiomatrix)氏の協力によりより[柔軟な領域指定](#2次元領域指定実験的機能)が可能になりました。
+
+
+# 概要
+Latent couple extentionではプロンプトごとにU-Netの計算を行っていますが、このエクステンションではU-Netの内部でプロンプトごとの計算を行います。詳しくは[こちら](https://note.com/gcem156/n/nb3d516e376d7)をご参照ください。アイデアを発案されたfurusu様に感謝いたします。
+
+## 使い方
+次の画像の作り方を解説しつつ、使い方を説明します。  
+![sample](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/sample.jpg)  
+以下がプロンプトです。
+```
+green hair twintail BREAK
+red blouse BREAK
+blue skirt
+```
+設定
+```
+Active : On
+Use base prompt : Off
+Divide mode : Vertical
+Divide Ratio : 1,1,1
+Base Ratio : 
+```
+この設定では縦方向に三分割し、上から順にgreen hair twintail ,red blouse ,blue skirtというプロンプトを適用しています。
+### Active  
+ここにチェックが入っている場合有効化します。
+
+### Prompt
+領域別のプロンプト同士はBREAKで区切ります。水平の場合は左から、垂直の場合は上から順にプロンプトを入力します。
+ネガティブプロンプトもBREAKで区切ることで領域ごとに設定できますが、BREAKを入力しない場合すべての領域に同一のネガティブプロンプトが設定されます。
+
+### Use base prompt
+ベースプロンプトとはすべての領域に共通のプロンプトを使用したい場合チェックを入れます。領域で一貫した場面にしたい場合などは使ってください。
+ベースプロンプトを使用する場合、BREAK区切られた最初のプロンプトがベースとして扱われます。
+ADDBASEが入力された場合、自動的にオンになります。
+
+### Base ratio
+ベースプロンプトの比率を設定します。0.2と入力された場合、ベースの割合が0.2になります。領域ごとにも指定可能で、0.2,0.3,0.5などと入力できます。単一の値を入力した場合はすべての領域に同じ値が適応されます。
+
+### Divide ratio
+領域の広さを指定します。1,1,1と入力した場合、三分割されます(33,3%,33,3%,33,3%)。3,1,1と入力した場合60%,20%,20%となります。小数点でも入力可能です。0.1,0.1,0.1は1,1,1と同じ結果になります。
+
+### calcutation mode  
+#### Attention  
+通常はこちらを使用して下さい
+#### Latent
+LoRAを分離したい場合こちらを使用して下さい。生成時間は長くなりますが、ある程度LoRAを分離できます。
+
+[ねんどろいど](https://civitai.com/models/7269/nendoroid-figures-lora),
+[figma](https://civitai.com/models/7984/figma-anime-figures)LoRAを左右に分離して作成した例。  
+<img src="https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/sample2.jpg" width="400">
+
+### Split mode
+分割方向を指定します。水平、垂直方向が指定できます。
+
+### Use common prompt
+このオプションを有効化すると最初のプロンプトをすべてのプロンプトに加算します。
+`ADDCOMM`が入力された場合自動的にオンになります。
+```
+best quality, 20yo lady in garden BREAK
+green hair twintail BREAK
+red blouse BREAK
+blue skirt
+```
+このようなプロンプトがあるときに、この機能を有効化すると以下のように扱われます。
+```
+best quality, 20yo lady in garden, green hair twintail BREAK
+best quality, 20yo lady in garden, red blouse BREAK
+best quality, 20yo lady in garden, blue skirt
+```
+よって、3つの領域に分ける場合4つのプロンプトをセットする必要があります。Use base promptが有効になっている場合は5つ必要になります。設定順はcommon,base, prompt1,prompt2,...となります。
+
+### 2次元領域指定(実験的機能)
+領域を2次元的に指定できます。特別なセパレイター(`ADDCOL/ADDROW`)を用いることで領域を縦横に分割することができます。左上を始点として、`ADDCOL`で区切ると横方向、`ADDROW`で区切ると縦方向に分割されます。分割の比率はセミコロンで区切られた比率で指定します。以下に例を示します。`BREAK`のみで記述し、比率のみで記述することも可能ですが、明示的にCOL/ROWを指定した方がわかりやすいです。最初のセパレーターとして`ADDBASE`を使用すると、ベースプロンプトになります。比率を指定しない場合や比率がセパレーターの数と一致しないときは自動的にすべて等倍として処理されます。`ADDCOMM`を最初のセパレーターとして入力した場合共通プロンプトになります。Divide modeで選択された方向は有効であり、上から/左から順に`ADDCOL/ADDROW`が処理されます。
+
+```
+(blue sky:1.2) ADDCOL
+green hair twintail ADDCOL
+(aquarium:1.3) ADDROW
+(messy desk:1.2) ADDCOL
+orange dress and sofa
+```
+
+```
+Active : On
+Use base prompt : Off
+Divide mode : Columns
+Divide Ratio : 1,2,1,1;2,4,6
+Base Ratio : 
+```
+
+![2d](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/2d.jpg)
+
+## <a id="inpaint">Mask regions aka inpaint+ (experimental function)</a>
+ 手描きマスク、またはアップロードされたマスクを使って領域を指定することができるようになりました。
+- まず、`Columns` / `Rows` の横にある `mask divide mode` に切り替えていることを確認してください。そうしないと、マスクは無視され、領域は通常通り分割されます。
+- キャンバスの幅と高さを希望する画像に合わせて設定し、`create mask area`を押してください。異なる比率やサイズを指定すると、マスクが正確に適用されないことがあります。（インペイントの「リサイズだけ」のように）。
+- キャンバス領域に必要な領域の輪郭を描くか、完全に塗りつぶした後、`draw region`を押してください。これにより、マスクに対応する塗りつぶし多角形が追加され、`region` の番号に従って色が付けられます。
+- draw region` を押すと、region が +1 ずつ増えていき、次のregion を素早く描画することができます。また、後でマスクを作るためにどのリージョンが使われたかのリストも保持されます。現在、最大で ~360~ 256 のリージョンが使用できます。
+- 既存のリージョンに追加するには、以前に使用された色を選択し、通常通り描画することが可能です。現在のところ、新しいマスク領域以外の領域をクリアする方法はありません（そのうちクリア機能は追加されるかもしれません）。
+- `make mask`ボタンは、以前に描いたリージョンについて、`region`の番号で指定されたマスクを表示します。マスクはリージョン固有の色によって検出されます。
+- リージョンマスクの準備ができたら、いつも通りプロンプトを書きます： 分割比率は無視されます。`base ratio`は各リージョンに適用されます。すべてのオプションがサポートされ、すべての BREAK / ADDX キーワード (ROW/COL は BREAK に変換されるだけです)。アテンションモードとレイテンモードがサポートされています。
+- ベースはマスクモードでは特別な変化をします： base が off のとき、色がついていない領域は最初のマスクに追加されます (したがって、最初のプロンプトで埋められるべきです)。base がオンのとき、色のついていないリージョンは base のプロンプトを反映します、色のついたリージョンは通常の base のウェイトを受け取ります。このため、baseはbase weight = 0で、シーン/背景を指定するのに特に便利なツールです。
+- 描画の代わりにマスクをアップロードしたい人向けです： この機能はまだ **非常に多くのWIP** であることに注意してください。マスクを適用するためには、すべての色に何らかのタグを付ける必要があります（コードでLCOLOUR変数を変更するか、手動で各色を画像に追加してください）。色はすべて `HSV(degree,50%,50%)` の変形で、 degree (0:360) は以前のすべての色から最大に離れた値として計算されます（そのため、色は容易に区別できます）。最初のいくつかの値は、基本的に 0、180、90、270、45、135、225、315、22.5などです。色の選択によって、どの領域に対応するかが決まります。
+
+![RegionalMaskGuideB](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/RegionalMaskGuideB.jpg)
+
+### visualise and make template
+複雑な領域指定をする場合など領域を可視化して、テンプレートを作成します。
+
+![tutorial](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/tutorial.jpg)
+
+入力を終えてボタンを押すと、画像のように領域とテンプレートが出力されます。テンプレートをコピペして使用して下さい。以下は入力例と出力結果です。
+
+```
+fantasy ADDCOMM
+sky ADDROW
+castle ADDROW
+street stalls ADDCOL
+2girls eating and walking on street ADDCOL
+street stalls
+```
+
+![tutorial](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/sample3.jpg
+)
+
+
+'1,1;2,3,2;3,2,3'を指定してColumnsを選んだ場合、  
+![flip](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/msapmle1.png)  
+Rowsに変えると  
+![flip](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/msapmle2.png)  
+flipを有効にすると
+![flip](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/msapmle3.png)	
+
+## <a id="divprompt">region specification by prompt (experimental)</a>
+プロンプトによる領域指定です。これまでの領域指定では分割された領域に対してプロンプトを設定していました。この領域指定にはいくつかの問題があり、例えば縦に分割した場合、指定したオブジェクトがそこに限定されてしまします。プロンプトによる領域指定では指定したプロンプトを反映した領域が画像生成中に作成され、そこに対応したプロンプトが適用されます。よって、より柔軟な領域指定が可能になります。以下に例を示します。`apple printed`は`shirt`にだけ効果が反映されて欲しいわけですが、shirtには反映されず、林檎の現物が出てきたりするわけです。
+```
+lady smiling and sitting, twintails green hair, white skirt, apple printed shirt
+```
+![prompt](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/psample1.png)
+そこで`apple printedの強度を1.4にするとこうなるわけです。
+
+![prompt](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/psample4.png)
+プロンプトによる領域指定ではshirtに対して領域を計算して、そこに`apple printed`を適用します。
+![prompt](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/psample6.png)
+```
+lady smiling and sitting, twintails green hair, white skirt, shirt BREAK
+(apple printed:1.4),shirt
+```
+![prompt](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/psample2.png)
+すると、目的の効果が得られるわけです。これまでの領域指定ではshirtの位置を詳細に指定しなければいけなかったわけですが、その必要がなくなりました。
+### つかいかた
+### 書式
+```
+baseprompt target1 target2 BREAK
+effect1, target1 BREAK
+effect2 ,target2
+```
+まず、ベースプロンプトを書きます。ベースプロンプトにはマスクを作成する単語（target1、target2）を書きます。次にBREAKで区切ります。次に、target1に対応するプロンプトを書きます。そしてカンマを入力しtarget1を記載します。ベースプロンプトのtargetの順番とBREAKで区切られたtargetの順番は前後しても問題ありません。targetは大まかな単語でも問題なく、例えば`tops`と指定して、`effect`に`red camisole`などと書いてもいいわけです。
+
+```
+target2 baseprompt target1  BREAK
+effect1, target1 BREAK
+effect2 ,target2
+```
+ベースプロンプトの順番は考慮されません。effectの順番は考慮されます。
+
+### threshold
+プロンプトによって作られるマスクの判定に使われる閾値です。これは対象となるプロンプトによって範囲が大きく異なるのでマスクの数だけ設定できます。複数の領域を使うときはカンマで区切って入力して下さい。例えば髪は領域が曖昧になりがちなので小さな値が必要ですが、顔は領域が大きくなりがちなので小さな値が必要です。これはBREAKで区切られた順に並べて下さい。
+
+```
+a lady ,hair, face  BREAK
+red, hair BREAK
+tanned ,face
+```
+`threshold : 0.4,0.6`
+単一の値が入力された場合、すべての領域に同じ値が適用されます。
+
+### Prompt and Prompt-EX
+領域がかぶった場合の計算方式です。Promptだと加算されます。Prompt-EXだと順番に上書きされます。つまり、target1とtarget2の領域が重複していた場合、target2の領域が優先されます。target1にtopsを指定してthretholdを小さくして大きな領域にして、target2をbottomsとしてthresholdを大きくすれ���良い分離が得られます。この場合、targetは領域が大きい順に記載されるべきです。
+
+### Accuracy
+12 x 512 サイズの場合、Attention modeではU-netの深い領域では 8 x 8 で計算されます。これでは小さい領域しては意味をなしません。よって領域の浸食が起きやすくなります。Latentモードでは 64*64で計算されるため領域が厳密になります。
+```
+girl hair twintail frills,ribbons, dress, face BREAK
+girl, ,face
+```
+Prompt-EX/Attention
+![prompt](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/psample5.png)
+Prompt-EX/Latent
+![prompt](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/psample3.png)
+
+
+
+### ベースと共通の違い
+```
+a girl ADDROMM(or ADDBASE)
+red hair BREAK
+green dress
+```
+と言うプロンプトがあった場合、共通の場合には領域1は`a girl red hair`というプロンプトで生成されます。ベースの場合で比率が0.2の場合には` (a girl) * 0.2 + (red hair) * 0.8`というプロンプトで生成されます。基本的には共通プロンプトで問題ありません。共通プロンプトの効きが強いという場合などはベースにしてみてもいいかもしれません。
+
+## APIを通した利用方法
+APIを通してこの拡張を利用する場合には次の書式を使います。
+```
+  "prompt": "green hair twintail BREAK red blouse BREAK blue skirt",
+	"alwayson_scripts": {
+		"Regional Prompter": {
+			"args": [True,False,"Matrix","Vertical","Mask","Prompt","1,1,1","",False,False,False,"Attention",False,"0","0","0",""]
+}}
+```
+`args`の各設定は下の表を参照して下さい。No.は順番に対応します。typeがtextになっている場合は`""`で囲って下さい。3-6のモード設定は3.のモードで選択したモードに対応するサブモード以外は無視されます。17.のマスクは画像データのアドレスを指定して下さい。アドレスは絶対パスか、web-uiルートからの相対パスが利用できます。マスクはマスクの項で指定された色を使用して作成して下さい。
+
+|  No.  |  setting  |choice| type  | default |
+| ---- | ---- |---- |----| ----|
+|  1  |  Active  |True, False|Bool|False| 
+|  2  | debug   |True, False|Bool|False| 
+|  3  | Mode  |Matrix, Mask, Prompt|Text| Matrix|
+|  4  | Mode (Matrix)|Horizontal, Vertical, Columns, Rows|Text|Columns
+|  5  | Mode (Mask)| Mask |Text|Mask 
+|  6  | Mode (Prompt)| Prompt, Prompt-Ex |Text|Prompt
+|  7 |  Ratios||Text|1,1,1
+|  8 |  Base Ratios  |  |Text| 0
+|  9 |  Use Base  |True, False|Bool|False| 
+|  10 | Use Common |True, False|Bool|False| 
+|  11 | Use Neg-Common   |True, False|Bool| False| 
+|  12 | Calcmode| Attention, Latent | Text  | Attention
+|  13 | Not Change AND   |True, False|Bool|False| 
+|  14 | LoRA Textencoder  ||Text|0|  
+|  15 | LoRA U-Net   |  | Text  | 0
+|  16 | Threshold   |  |Text| 0
+|  17 | Mask   |  | Text | 
+
+### 設定例
+#### Matrix
+```
+  "prompt": "green hair twintail BREAK red blouse BREAK blue skirt",
+	"alwayson_scripts": {
+		"Regional Prompter": {
+			"args": [True,False,"Matrix","Vertical","Mask","Prompt","1,1,1","",False,False,False,"Attention",False,"0","0","0",""]
+}}
+```
+結果
+![sample](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/asample1.png)  
+
+#### Mask
+```
+   "prompt": "masterpiece,best quality 8k photo of BREAK (red:1.2) forest BREAK yellow chair BREAK blue dress girl",
+	"alwayson_scripts": {
+		"Regional Prompter": {
+			"args":	[True,False,"Mask","Vertical","Mask","Prompt","1,1,1","",False,True,False,"Attention",False,"0","0","0","mask.png"]
+```
+使用したマスク
+![sample](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/mask.png)  
+結果
+![sample](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/asample2.png)  
+
+### Prompt
+```
+ "prompt": "masterpiece,best quality 8k photo of BREAK a girl hair blouse skirt with bag BREAK (red:1.8) ,hair BREAK (green:1.5),blouse BREAK,(blue:1.7), skirt BREAK (yellow:1.7), bag",
+	"alwayson_scripts": {
+		"Regional Prompter": {
+			"args":	[True,False,"Prompt","Vertical","Mask","Prompt-EX","1,1,1","",False,True,False,"Attention",False,"0","0","0.5,0.6,0.5",""]
+}}
+```
+![sample](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/asample3.png)  
+
+### 謝辞
+Attention coupleを提案された[furusu](https://note.com/gcem156)氏、Latent coupleを提案された[opparco](https://github.com/opparco)氏、2D生成のコード作成に協力して頂いた[Symbiomatrix](https://github.com/Symbiomatrix)に感謝します。
+
+
+
+- 新機能2D領域を追加しました
+- 新しい計算方式「Latent」を追加しました。生成が遅くなりますがLoRAをある程度分離できます
+- 75トークン以上を入力できるようになりました
+- 共通プロンプトを設定できるようになりました
+- 設定がPNG infoに保存されるようにな��ました

regional-prompter-main/README.md

@@ -0,0 +1,406 @@
+# Regional Prompter
+![top](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/top.jpg)
+- custom script for [AUTOMATIC1111's stable-diffusion-webui](https://github.com/AUTOMATIC1111/stable-diffusion-webui) 
+- Different prompts can be specified for different regions
+
+- [AUTOMATIC1111's stable-diffusion-webui](https://github.com/AUTOMATIC1111/stable-diffusion-webui) 用のスクリプトです
+- 垂直/平行方向に分割された領域ごとに異なるプロンプトを指定できます
+
+## Language control / 言語制御
+日本語: [![jp](https://img.shields.io/badge/lang-jp-green.svg)](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/main/README.JP.md)
+
+### Updates
+- モード名が変更になりました。`Horizontal` -> `columns`, `Vertical` -> `Rows`
+(日本語で横に分割を英訳したSplit Horizontalは英語圏では逆の意味になるようです。水平線「で」分割するという意味になるそう)
+- `,`,`;`を入れ替えるオプションを追加
+
+- Split Mode name changed, `Horizontal` -> `columns`, `Vertical` -> `Rows`
+- flip `,`,`;` option added
+
+- add LoRA stop step
+LoRAを適用するのをやめるstepを指定できます。10 step程度で停止することで浸食、ノイズ等の防止、生成速度の向上を期待できます。
+You can specify the step at which to stop applying LoRA. By stopping around 10 steps, you can expect to prevent erosion and noise, and to improve generation speed.
+(0に設定すると無効になります。0 is disable)
+
+- support SDXL
+- support web-ui 1.5
+
+- add [guide for API users](#how-to-use-via-api)
+
+- prompt mode improved
+- プロンプトモードの動作が改善しました  
+(The process has been adjusted to generate masks in three steps, and to recommence generation from the first stage./3ステップでマスクを生成し、そこから生成を1stepからやり直すよう修正しました)
+
+- New feature : [regions by inpaint](#inpaint) (thanks [Symbiomatrix](https://github.com/Symbiomatrix))
+- New feature : [regions by prompt](#divprompt) ([Tutorial](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/main/prompt_en.md)) 
+- 新機能 : [インペイントによる領域指定](#inpaint) (thanks [Symbiomatrix](https://github.com/Symbiomatrix))
+- 新機能 : [プロンプトによる領域指定](#divprompt) ([チュートリアル](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/main/prompt_ja.md))
+
+
+# Overview
+Latent couple extention performs U-Net calculations on a per-prompt basis, but this extension performs per-prompt calculations inside U-Net. See [here(Japanese)](https://note.com/gcem156/n/nb3d516e376d7) for details. Thanks to furusu for initiating the idea. Additional, Latent mode also supported.
+
+## index
+- [2D regions](#2D)
+- [Latent mode(LoRA)](#latent) 
+- [regions by inpaint](#inpaint) 
+- [regions by prompt](#divprompt) 
+
+		
+																																																																																								 
+
+## Usage
+This section explains how to use the following image, explaining how to create the following image.  
+![sample](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/sample.jpg)  
+Here is the prompt.
+```
+green hair twintail BREAK
+red blouse BREAK
+blue skirt
+```
+setting
+```
+Active : On
+Use base prompt : Off
+Divide mode : Vertical
+Divide Ratio : 1,1,1
+Base Ratio : 
+````
+This setting divides the image vertically into three parts and applies the prompts "green hair twintail" ,"red blouse" ,"blue skirt", from top to bottom in order.
+
+### Active  
+This extention is enabled only if "Active" is toggled.
+
+### Prompt
+Prompts for different regions are separated by `BREAK` keywords. 
+Negative prompts can also be set for each area by separating them with `BREAK`, but if `BREAK` is not entered, the same negative prompt will be set for all areas.
+
+Using `ADDROW` or `ADDCOL` anywhere in the prompt will automatically activate [2D region mode](#2D).
+
+### Use base prompt
+Check this if you want to use the base prompt, which is the same prompt for all areas. Use this option if you want the prompt to be consistent across all areas.
+When using base prompt, the first prompt separated by `BREAK` is treated as the base prompt.
+Therefore, when this option is enabled, one extra `BREAK`-separated prompt is required compared to Divide ratios.
+
+Automatically turned on when `ADDBASE` is entered.
+																																				   
+
+### Divide ratio
+If you enter 1,1,1, the image will be divided into three equal regions (33,3%, 33,3%, 33,3%); if you enter 3,1,1, the image will be divided into 60%, 20%, and 20%. Fractions can also be entered: 0.1,0.1,0.1 is equivalent to 1,1,1. For greatest accuracy, enter pixel values corresponding to height / width (vertical / horizontal mode respectively), eg 300,100,112 -> 512.
+
+					  
+				
+										  
+		   
+																		
+
+Using a `;` separator will automatically activate 2D region mode.
+													  
+																									  
+
+### Base ratio
+Sets the ratio of the base prompt; if base ratio is set to 0.2, then resulting images will consist of `20%*BASE_PROMPT + 80%*REGION_PROMPT`. It can also be specified for each region, in the same way as "Divide ratio" - 0.2, 0.3, 0.5, etc. If a single value is entered, the same value will be applied to all areas.
+
+### split mode
+Specifies the direction of division. Horizontal and vertical directions can be specified.
+In order to specify both horizontal and vertical regions, see 2D region mode.
+
+## calcutation mode  
+### Attention  
+Normally, use this one.  
+### Latent
+Slower, but allows separating LoRAs to some extent. The generation time is the number of areas x the generation time of one pic. See [known issues](#knownissues).
+
+Example of Latent mode for [nendoorid](https://civitai.com/models/7269/nendoroid-figures-lora),
+[figma](https://civitai.com/models/7984/figma-anime-figures) LoRA separated into left and right sides to create.  
+<img src="https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/sample2.jpg" width="400">
+
+### Use common prompt
+If this option enabled, first part of the prompt is added to all region parts.
+
+Automatically turned on when `ADDCOMM` is entered.
+```
+best quality, 20yo lady in garden BREAK
+green hair twintail BREAK
+red blouse BREAK
+blue skirt
+```
+If common is enabled, this prompt is converted to the following:
+```
+best quality, 20yo lady in garden, green hair twintail BREAK
+best quality, 20yo lady in garden, red blouse BREAK
+best quality, 20yo lady in garden, blue skirt
+```
+So you must set 4 prompts for 3 regions. If `Use base prompt` is also enabled 5 prompts are needed. The order is as follows: common, base, prompt1,prompt2,...
+
+## <a id="2D">2D region assignment</a>
+You can specify a region in two dimensions. Using a special separator (`ADDCOL/ADDROW`), the area can be divided horizontally and vertically. Starting at the upper left corner, the area is splited by columns when separated by `ADDCOL` and rows when separated by `ADDROW`. The ratio of division is specified as a ratio separated by a semicolon. An example is shown below; although it is possible to use `BREAK` alone to describe only the ratio, it is easier to understand if COL/ROW is explicitly specified. Using `ADDBASE `as the first separator will result in the base prompt. If no ratio is specified or if the ratio does not match the number of separators, all regions are automatically treated as equal multiples.
+In this mode, the direction selected in `Divide mode` changes which separator is applied first:
+- In `Coloms` mode, the image is first split to rows with `ADDROW` or `;` in Divide ratio, then each row is split to regions with `ADDCOL` or `,` in Divide ratio.
+- In `Rows` mode, the image is first split to columns with `ADDCOL` or `,` in Divide ratio, then each column is split to regions with `ADDROW` or `;` in Divide ratio.
+- When the flip option is enabled, it swaps the , and ;. This allows you to obtain an area that is rotated 90 degrees while keeping the same ratios used in Columns/Rows.
+  
+In any case, the conversion of prompt clauses to rows and columns is from top to bottom, left to right.
+
+```
+(blue sky:1.2) ADDCOL
+green hair twintail ADDCOL
+(aquarium:1.3) ADDROW
+(messy desk:1.2) ADDCOL
+orange dress and sofa
+```
+
+```
+Active : On
+Use base prompt : Off
+Main splitting : Columns
+Divide Ratio : 1,2,1,1;2,4,6
+Base Ratio : 
+```
+
+![2d](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/2d.jpg)
+
+																		 
+																																					
+																																																								   
+																																			 
+																																																											  
+																																																											  
+																																			  
+																																																																  
+																																																																																
+																																																																																																																																			
+
+																												
+
+## <a id="visualize">Visualise and make template</a>
+Areas can be visualized and templates for prompts can be created.
+
+![tutorial](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/tutorial.jpg)
+
+Enter the area ratio and press the button to make the area appear. Next, copy and paste the prompt template into the prompt input field.
+
+```
+fantasy ADDCOMM
+sky ADDROW
+castle ADDROW
+street stalls ADDCOL
+2girls eating and walking on street ADDCOL
+street stalls
+```
+Result is following,
+![tutorial](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/sample3.jpg)
+
+
+This is an example of an area using 1,1;2,3,2;3,2,3. In Columns, it would look like this:  
+![flip](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/msapmle1.png)  
+In Rows, it would appear as follows:  
+![flip](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/msapmle2.png)  
+When the flip option is enabled in Rows, it would appear as follows:  
+![flip](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/msapmle3.png)	  																																							  
+ 
+
+## <a id="inpaint">Mask regions aka inpaint+ (experimental function)</a>
+It is now possible to specify regions using either multiple hand drawn masks or an uploaded image containing said masks (more on that later).
+- First, make sure you switch to `mask divide mode` next to `Colums` / `Rows`. Otherwise the mask will be ignored and regions will be split by ratios as usual.
+- Set `canvas width and height` according to desired image's, then press `create mask area`. If a different ratio or size is specified, the masks may be applied inaccurately (like in inpaint "just resize").
+- Draw an outline / area of the region desired on the canvas, then press `draw region`. This will fill out the area, and colour it according to the `region` number you picked. **Note that the drawing is in black only, filling and colouring are performed automatically.** The region mask will be displayed below, to the right.
+- Pressing `draw region` will automatically advance to the next region. It will also keep a list of which regions were used for building the masks later. Up to 360 regions can be used currently, but note that a few of them on the higher end are identical.
+- It's possible to add to existing regions by reselecting the same number and drawing as usual.
+- The special region number -1 will clear out (colour white) any drawn areas, and display which parts still contain regions in mask.
+- Once the region masks are ready, write your prompt as usual: Divide ratios are ignored. Base ratios still apply to each region. All flags are supported, and all BREAK / ADDX keywords (ROW/COL will just be converted to BREAK). Attention and latent mode supported (loras maybe).
+- `Base` has unique rules in mask mode: When base is off, any non coloured regions are added to the first mask (therefore should be filled with the first prompt). When base is on, any non coloured regions will receive the base prompt in full, whilst coloured regions will receive the usual base weight. This makes base a particularly useful tool for specifying scene / background, with base weight = 0.
+- Masks are saved to and loaded from presets whose divide mode is `mask`. The mask is saved in the extension directory, under the folder `regional_masks`, as {preset}.png file.
+- Masks can be uploaded from any image by using the empty component labelled `upload mask here`. It will automatically filter and tag the colours approximating matching those used for regions, and ignore the rest. The region / nonregion sections will be displayed under mask. **Do not upload directly to sketch area, and read the [known issues](#knownissues) section.**
+- If you wish to draw masks in an image editor, this is how the colours correspond to regions: The colours are all variants of `HSV(degree,50%,50%)`, where degree (0:360) is calculated as the maximally distant value from all previous colours (so colours are easily distinguishable). The first few values are essentially: 0, 180, 90, 270, 45, 135, 225, 315, 22.5 and so on. The choice of colours decides to which region they correspond.
+- Protip: You may upload an openpose / depthmap / any other image, then trace the regions accordingly. Masking will ignore colours which don't belong to the expected colour standard.
+
+![RegionalMaskGuide2](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/RegionalMaskGuide2.jpg)
+![RegionalMaskGuide2B](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/RegionalMaskGuide2B.jpg)
+
+
+Here is sample and code  
+using mask and prompt`landscape BREAK moon BREAK girl`.
+Using XYZ plot prompt S/R, changed `moon BREAK girl` to others.  
+![RegionalMaskSample](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/isample1.png)
+
+
+
+## <a id="divprompt">region specification by prompt (experimental)</a>
+The region is specified by the prompt. The picture below was created with the following prompt, but the prompt `apple printed` should only affect the shirt, but the actual apples are shown and so on. 
+```
+lady smiling and sitting, twintails green hair, white skirt, apple printed shirt
+```
+![prompt](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/psample1.png)
+If you enhance the effect of `apple printed` to `:1.4`, you get, 
+
+![prompt](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/psample4.png)
+The prompt region specification allows you to calculate the region for the "shirt" and adapt the "printed apples".
+
+![prompt](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/psample6.png)
+```
+lady smiling and sitting, twintails green hair, white skirt, shirt BREAK
+(apple printed:1.4),shirt
+```
+![prompt](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/psample2.png)
+
+### How to use
+### syntax
+```
+baseprompt target1 target2 BREAK
+effect1, target1 BREAK
+effect2 ,target2
+```
+																																																																																			 
+
+First, write the base prompt. In the base prompt, write the words (target1, target2) for which you want to create a mask. Next, separate them with BREAK. Next, write the prompt corresponding to target1. Then enter a comma and write target1. The order of the targets in the base prompt and the order of the BREAK-separated targets can be back to back.
+
+```
+target2 baseprompt target1  BREAK
+effect1, target1 BREAK
+effect2 ,target2
+```
+is also effective.
+
+### threshold
+The threshold used to determine the mask created by the prompt. This can be set as many times as there are masks, as the range varies widely depending on the target prompt. If multiple areas are used, enter them separated by commas. For example, hair tends to be ambiguous and requires a small value, while face tends to be large and requires a small value. These should be ordered by BREAK.
+
+```
+a lady ,hair, face  BREAK
+red, hair BREAK
+tanned ,face
+```
+`threshold : 0.4,0.6`
+If only one input is given for multiple regions, they are all assumed to be the same value.
+
+### Prompt and Prompt-EX
+The difference is that in Prompt, duplicate areas are added, whereas in Prompt-EX, duplicate areas are overwritten sequentially. Since they are processed in order, setting a TARGET with a large area first makes it easier for the effect of small areas to remain unmuffled.
+
+### Accuracy
+In the case of a 512 x 512 image, Attention mode reduces the size of the region to about 8 x 8 pixels deep in the U-Net, so that small areas get mixed up; Latent mode calculates 64*64, so that the region is exact.  
+```
+girl hair twintail frills,ribbons, dress, face BREAK
+girl, ,face
+```
+Prompt-EX/Attention
+![prompt](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/psample5.png)
+Prompt-EX/Latent
+![prompt](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/psample3.png)
+
+
+### Mask
+When an image is generated, the generated mask is displayed. It is generated at the same size as the image, but is actually used at a much smaller size.
+
+## Difference between base and common
+```
+a girl ADDCOMM (or ADDBASE)
+red hair BREAK
+green dress
+```
+If there is a prompt that says `a girl` in the common clause, region 1 is generated with the prompt `a girl , red hair`. In the base clause, if the base ratio is 0.2, it is generated with the prompt `a girl` * 0.2 + `red hair` * 0.8. Basically, common clause combines prompts, and base clause combines weights (like img2img denoising strength). You may want to try the base if the common prompt is too strong, or fine tune the (emphasis).
+The immediate strength that corresponds to the target should be stronger than normal. Even 1.6 doesn't break anything.
+
+## <a id="knownissues">Known issues</a>
+- Due to an [issue with gradio](https://github.com/gradio-app/gradio/issues/4088), uploading a mask or loading a mask preset more than twice in a row will fail. There are two workarounds for this:
+1) Before EVERY upload / load, press `create mask area`.
+2) Modify the code in gradio.components.Image.preprocess; add the following at the beginning of the function (temporarily):
+```
+        if self.tool == "sketch" and self.source in ["upload", "webcam"]:
+            if x is not None and isinstance(x, str):
+                x = {"image":x, "mask": x[:]}
+```
+The extension cannot perform this override automatically, because gradio doesn't currently support [custom components](https://github.com/gradio-app/gradio/issues/1432). Attempting to override the component / method in the extension causes the application to not load at all.
+
+3) Wait until a fix is published.
+
+- Lora corruption in latent mode. Some attempts have been made to improve the output, but no solution as of yet. Suggestions below.
+1) Reduce cfg, reduce lora weight, increase sampling steps.
+2) Use the `negative textencoder` + `negative U-net` parameters: these are weights between 0 and 1, comma separated like base. One is applied to each lora in order of appearance in the prompt. A value of 0 (the default) will negate the effect of the lora on other regions, but may cause it to be corrupted. A value of 1 should be closer to the natural effect, but may corrupt other regions (greenout, blackout, SBAHJified etc), even if they don't contain any loras. In both cases, a higher lora weight amplifies the effect. The effect seems to vary per lora, possibly per combination.
+3) It has been suggested that [lora block weight](https://github.com/hako-mikan/sd-webui-lora-block-weight) can help.
+4) If all else fails, inpaint.
+
+Here are samples of a simple prompt, two loras with negative te/unet values per lora of: (0,0) default, (1,0), (0,1), (1,1).
+![MeguminMigurdiaCmp](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/MeguminMigurdiaCmp.jpg)
+
+If you come across any useful insights on the phenomenon, do share.
+
+## How to Use via API
+The following format is used when utilizing this extension via the API.
+
+```
+  "prompt": "green hair twintail BREAK red blouse BREAK blue skirt",
+	"alwayson_scripts": {
+		"Regional Prompter": {
+			"args": [True,False,"Matrix","Vertical","Mask","Prompt","1,1,1","",False,False,False,"Attention",False,"0","0","0",""]
+}}
+```
+Please refer to the table below for each setting in `args`. No. corresponds to the order. When the type is text, please enclose it with `""`. Modes 3-6 ignore submodes that do not correspond to the mode selected in mode 3. For the mask in 17., please specify the address of the image data. Absolute paths or relative paths from the web-ui root can be used. Please create the mask using the color specified in the mask item.
+
+|  No.  |  setting  |choice| type  | default |
+| ---- | ---- |---- |----| ----|
+|  1  |  Active  |True, False|Bool|False| 
+|  2  | debug   |True, False|Bool|False| 
+|  3  | Mode  |Matrix, Mask, Prompt|Text| Matrix|
+|  4  | Mode (Matrix)|Horizontal, Vertical, Colums, Rows|Text|Columns
+|  5  | Mode (Mask)| Mask |Text|Mask 
+|  6  | Mode (Prompt)| Prompt, Prompt-Ex |Text|Prompt
+|  7 |  Ratios||Text|1,1,1
+|  8 |  Base Ratios  |  |Text| 0
+|  9 |  Use Base  |True, False|Bool|False| 
+|  10 | Use Common |True, False|Bool|False| 
+|  11 | Use Neg-Common   |True, False|Bool| False| 
+|  12 | Calcmode| Attention, Latent | Text  | Attention
+|  13 | Not Change AND   |True, False|Bool|False| 
+|  14 | LoRA Textencoder  ||Text|0|  
+|  15 | LoRA U-Net   |  | Text  | 0
+|  16 | Threshold   |  |Text| 0
+|  17 | Mask   |  | Text | 
+|  18 | LoRA stop step   |  | Text | 0
+|  19 | LoRA Hires stop step   |  | Text | 0
+|  20 | flip   |True, False| Bool | False
+
+### Example Settings
+#### Matrix
+```
+  "prompt": "green hair twintail BREAK red blouse BREAK blue skirt",
+	"alwayson_scripts": {
+		"Regional Prompter": {
+			"args": [True,False,"Matrix","Vertical","Mask","Prompt","1,1,1","",False,False,False,"Attention",False,"0","0","0",""]
+}}
+```
+Result
+![sample](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/asample1.png)  
+
+#### Mask
+```
+   "prompt": "masterpiece,best quality 8k photo of BREAK (red:1.2) forest BREAK yellow chair BREAK blue dress girl",
+	"alwayson_scripts": {
+		"Regional Prompter": {
+			"args":	[True,False,"Mask","Vertical","Mask","Prompt","1,1,1","",False,True,False,"Attention",False,"0","0","0","mask.png"]
+```
+Mask used
+![sample](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/mask.png)  
+Result
+![sample](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/asample2.png)  
+
+#### Prompt
+```
+ "prompt": "masterpiece,best quality 8k photo of BREAK a girl hair blouse skirt with bag BREAK (red:1.8) ,hair BREAK (green:1.5),blouse BREAK,(blue:1.7), skirt BREAK (yellow:1.7), bag",
+	"alwayson_scripts": {
+		"Regional Prompter": {
+			"args":	[True,False,"Prompt","Vertical","Mask","Prompt-EX","1,1,1","",False,True,False,"Attention",False,"0","0","0.5,0.6,0.5",""]
+}}
+```
+![sample](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/asample3.png)  
+
+
+## Acknowledgments
+I thank [furusu](https://note.com/gcem156) for suggesting the Attention couple, [opparco](https://github.com/opparco) for suggesting the Latent couple, and [Symbiomatrix](https://github.com/Symbiomatrix) for helping to create the 2D generation code.
+
+
+## Updates
+- New feature, "2D-Region"
+- New generation method "Latent" added. Generation is slower, but LoRA can be separated to some extent.
+- Supports over 75 tokens
+- Common prompts can be set
+- Setting parameters saved in PNG info

regional-prompter-main/prompt_en.md

@@ -0,0 +1,137 @@
+Tutorial on specifying areas with prompts
+
+There are limitations to methods of specifying areas in advance. This is because specifying areas can be a hindrance when designating complex shapes or dynamic compositions. In the region specified by the prompt, the area is determined after the image generation has begun. This allows us to accommodate compositions and complex areas.
+
+Let's take a look at an example.
+The following image was created by the next prompt. It's a grand color transition.
+```
+sfw (8k realistic masterpiece:1.3) a Asian girl ,dark green dress,pink belt,yellow bag,
+blond hair, in rainy street, holding red umbrella
+```
+![1](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial9.png)  
+Now, if we try to manage this with the usual area designation, we will have trouble specifying the area for the umbrella and the bag. They appear in various places, and some areas are initially small.
+
+With prompt-based area specification, we calculate the area corresponding to each word.
+
+Let's first turn the umbrella red. We change the prompt as follows: we change red umbrella to umbrella and after BREAK, we add (red:1.7), umbrella. This is because the system calculates the area of the word written after the last comma in the prompt following BREAK. In the case of (red:1.7), umbrella, the area of umbrella is calculated, and (red:1.7) is applied to that area.
+
+Intensity adjustment is very important. Normally, if you input 1.7, it tends to fall apart, but with prompt-based area specification, it doesn't work unless you put in about this value. It's especially better to increase the intensity if you're trying to specify a color that doesn't seem to have learned much.
+```
+sfw (8k realistic masterpiece:1.3) a girl, (dress:1.2), belt, bag, hair, in rainy street, holding umbrella BREAK
+(red:1.7), umbrella  
+```
+
+```
+Divide mode : Prompt-EX
+Calcmode : Attention
+threshold : 0.7
+negative common prompt : Enable
+```
+Prompt-EX mode is an effective mode for specifying multiple areas and has the effect of overwriting areas with the ones that come later. Therefore, it is effective to specify the areas in a larger order.
+
+Then the umbrella became properly red. The second image is the calculated area. It's properly shaped like an umbrella, and the head part is out of the area. This area varies depending on the prompt, so it's necessary to adjust it with the Threshold. If the Threshold is small, the area will be wider.
+![1](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial11.png)
+
+Here, negative prompts are also set up.
+```
+nsfw, (worst quality:1.6), (low quality:1.6), (normal quality:1.6), monochrome 
+[(black:1.5)::3] BREAK BREAK (dark,transparent, black, blue:2)  
+```
+Umbrellas and bags tend to be predominantly black in the data the model was trained on, so caution is required when specifying colors for them. In this case, we've added a prompt to prevent the umbrella area from becoming black. The reason there are two BREAKs is because nega is enabled. [(black:1.5)::3] prevents the image from becoming black before the region specification by the prompt begins. In the region specification by the prompt, the calculation of the region is not valid until the third step.
+
+Now, with similar region specification, the prompt becomes as follows, and we were able to obtain a result where the colors were properly separated.
+
+```
+sfw (8k realistic masterpiece:1.3) a girl, (dress:1.2), belt, bag, hair, in rainy street, holding umbrella BREAK
+(red:1.7), umbrella  BREAK
+(dark green:1.7) ,dress BREAK
+(blond:1.7), hair BREAK
+(pink:1.7), belt BREAK
+(yellow:1.7), bag
+```
+
+![1](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial10.png)
+
+
+
+The following image was created with the prompt below. Although it would be ideal if 'forest' was only applied to the T-shirt, the background has also become a forest.
+```
+girl in street (forest printed:1.3) T-shirt, shortshorts daytime
+```
+![1](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial1.png)
+To apply the 'forest' print only to the T-shirt, we configure the prompt and the Regional Prompter as follows.
+```
+lady in street shirt,shortshorts daytime BREAK
+(forest printed:1.3) T-shirt ,shirt
+```
+What's important here is that `shirt` is both placed before the `BREAK` and at the end after the 'BREAK', and is separated by a comma. In prompt mode, the word that is separated by a comma at the end is the target for region calculation.
+```
+Divide mode : Prompt
+Calcmode : Attention
+threshold : 0.7
+```
+
+With these settings, the generation will look like this.  
+![2](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial2.png)  
+mask   
+![3](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial3.png)    
+This is a property of the Attention mode, where it actually shrinks to about 12×8, making it more ambiguous, which might be better.
+
+Now, there seems to be a strange string attached to the "shortshort", so let's change this next. We rewrite the prompt as follows.
+```
+girl in street shirt,shortshorts daytime BREAK
+(forest printed:1.3) T-shirt ,shirt BREAK
+(skirt:1.7) ,shortshorts
+```
+```
+Divide mode : Prompt
+Calcmode : Attention
+threshold : 0.7,0.75
+```
+It turns out like this.
+![4](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial4.png)    
+The `shortshorts` became a `skirt`. I wrote it as `shortshorts` because that's what it was initially, but using a word like `bottoms` can make region selection easier. The reason why I kept it as `shortshorts` this time is because I didn't want to change the base prompt. If you change `shortshorts` to `bottoms`, it changes the initial image itself.
+
+```
+girl in street shirt,bottoms daytime BREAK
+(forest printed:1.3) T-shirt ,shirt BREAK
+(red skirt:1.7) ,bottoms
+```
+third image is made from this prompt.
+![5](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial5.png)   
+Keeping it as `shortshorts` only changes the area around the `shortshorts`, but if you change `shortshorts` to `bottoms`, it changes the base, which changes the whole image. In other words, with prompt-based specifications, you can do something like inpainting where only a part is changed.
+
+Let's change the settings a bit and try dressing up. The reason why I set it as` (shortshorts:0.5)` is to prioritize the `skirt`. Weakening the `shortshorts` for the region won't be a problem. Normally, you target the same item, but if the word is too strong, it will have too much impact, so weakening it is an option.
+
+```
+girl in street shirt,shortshorts daytime BREAK
+(forest printed:1.3) T-shirt ,shirt BREAK
+(red skirt:1.5) ,(shortshorts:0.5)
+```
+```
+Divide mode : Prompt
+Calcmode : Attention
+threshold : 0.7,0.55
+```
+I'm broadening the `threshold` for `shortshorts` to accommodate things like long skirt. I think bottoms or lower body would be easier.
+![6](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial6.png)  
+We were able to change the clothes, but there's some erosion in the pink. This is because the intensity is set uniformly. If we refine the settings, the erosion should disappear.
+
+```
+girl in street shirt,shortshorts daytime BREAK
+(forest printed:1.3) T-shirt ,shirt BREAK
+(red skirt:1.5) ,(shortshorts:0.5) BREAK
+(Japan landscape:1.6),street
+```
+```
+Divide mode : Prompt
+Calcmode : Attention
+threshold : 0.7,0.55,0.7
+```
+Let's change the `Japan` part.
+![7](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial7.png)  
+The word `landscape` is a bit tricky. It's quite strong and often cancels out the effect of other words. However, by calculating the region using street instead of `landscape`, we can prevent it from becoming overly dominant. By calculating regions with different words like this, you might be able to expand the range of your expressions.
+
+When the Regional Prompter is disabled, it looks like this.
+This is pretty good as it is.
+![8](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial8.png)    

regional-prompter-main/prompt_ja.md

@@ -0,0 +1,136 @@
+## promptで指定する領域のチュートリアル
+あらかじめ領域を指定するタイプの方法には限界があります。複雑な形状や動的な構図を指定する場合には領域指定が足かせになるためです。promptで指定する領域では画像を生成し始めたあとで領域を決定します。これにより構図や複雑な領域にも対応できるようになります。
+
+では例を見てみましょう。
+下記の画像は次のプロンプトによって作成されました。まぁ盛大に色移りするわけです。
+```
+sfw (8k realistic masterpiece:1.3) a Asian girl ,dark green dress,pink belt,yellow bag,
+blond hair, in rainy street, holding red umbrella
+```
+![1](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial9.png)  
+さてこれを通常の領域指定でなんとかしようとすると傘やバッグの領域指定に困ってしまうわけです。色々な場所に出てくるし、そもそも領域が小さかったりします。
+
+プロンプトによる領域指定では1単語に対応する領域を計算します。
+
+まずは傘から赤くしてみましょう。プロンプトを以下のように変更します。`red umbrella`を`umbrella`に変更し、`BREAK`のあとに`(red:1.7)`, `umbrella`を追記します。これは`BREAK`のあとに続くプロンプトでは最後のカンマのあとに書かれた単語の領域を計算する仕組みだからです。`(red:1.7), umbrella`の場合、`umbrella`の領域が計算され、その領域に`(red:1.7)`が掛かります。
+強度調節はとても大切で、通常1.7を入力すると崩壊気味になるわけですが、プロンプトによる領域指定ではこれぐらいの値を入れないと効きません。特にあまり学習していないような色を指定しようとするなら強度を高めたほうが良いです。
+```
+sfw (8k realistic masterpiece:1.3) a girl, (dress:1.2), belt, bag, hair, in rainy street, holding umbrella BREAK
+(red:1.7), umbrella  
+```
+
+```
+Divide mode : Prompt-EX
+Calcmode : Attention
+threshold : 0.7
+negative common prompt : Enable
+```
+Prompt-EXモードは複数の領域を指定する場合に有効なモードで、あとに来る領域によって領域を上書きする効果があります。よって大きな順に領域を指定すると効果的です。
+するとちゃんと傘が赤くなりました。２枚目の画像は計算された領域でです。ちゃんと傘の形になっていて、かつ頭の部分は領域外になっているわけです。この領域はpromptによってまちまちなのでThresholdで調節してあげる必要があります。Thresholdは小さいと領域が広くなります。  
+![1](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial11.png)
+
+ここではネガティブプロンプトも設定しています。
+```
+nsfw, (worst quality:1.6), (low quality:1.6), (normal quality:1.6), monochrome 
+[(black:1.5)::3] BREAK BREAK (dark,transparent, black, blue:2)  
+```
+傘やバッグなどはもともと黒いものが多く学習されている傾向があるので色を指定するときには注意が必要です。ここでは傘の領域に黒くなるのを防ぐpromptを入れています。`BREAK`が２つ並んでいるのはnegative commom promptを有効にしているためです。`[(black:1.5)::3]`はpromptによる領域指定が始まる前の段階で黒くなるのを防いでいます。promptによる領域指定では3stepまでは領域計算ができていないので有効になっていません。
+
+さて、同様の領域指定を行うことでプロンプトは下記のようになり、ちゃんと色分けできた結果が得られました。
+
+```
+sfw (8k realistic masterpiece:1.3) a girl, (dress:1.2), belt, bag, hair, in rainy street, holding umbrella BREAK
+(red:1.7), umbrella  BREAK
+(dark green:1.7) ,dress BREAK
+(blond:1.7), hair BREAK
+(pink:1.7), belt BREAK
+(yellow:1.7), bag
+```
+
+![1](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial10.png)
+
+  　
+  
+次の絵は以下のプロンプトで作られました。forestはT-シャツにだけ書いてくれればいいものの、背景まで森になっています。
+```
+girl in street (forest printed:1.3) T-shirt, shortshorts daytime
+```
+![1](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial1.png)
+そこで、Tシャツのみにforest printetを効かせるためにプロンプトとRegional Prompterを以下のように設定します。
+```
+lady in street shirt,shortshorts daytime BREAK
+(forest printed:1.3) T-shirt ,shirt
+```
+ここで大切なのはshirtがBREAKの前に入っていることと、BREAKのあと、最後にあることとカンマで区切られていることです。promptモードでは最後にカンマで区切られた単語を領域計算の対象にします。
+```
+Divide mode : Prompt
+Calcmode : Attention
+threshold : 0.7
+```
+divide ratioとbase ratioはいまのところ使用しません。
+この設定で生成すると次のようになります。  
+![2](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial2.png)  
+実際に生成されたマスクはこんな感じです。    
+![3](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial3.png)    
+これはAttention modeの性質で、実際には12×8程度にまで縮小されて曖昧になるのでむしろこれくらいの方がよかったりします。
+
+さて、なんだかshortshortにへんなひもがついているので次はここを変えてみましょう。プロンプトを以下のように書き換えます。
+```
+girl in street shirt,shortshorts daytime BREAK
+(forest printed:1.3) T-shirt ,shirt BREAK
+(skirt:1.7) ,shortshorts
+```
+```
+Divide mode : Prompt
+Calcmode : Attention
+threshold : 0.7,0.75
+```
+するとこうなります。  
+![4](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial4.png)    
+`shortshorts`が`skirt`になりました。今回は最初がshortshortsだったのでそのまま書き換えましたが、`bottoms`などのような単語を使った方が領域選択が簡単です。なぜ今回`shortshors`のままにしたかというと、ベースとなるプロンプトを変えたくなかったからです。`shortshorts`を`bottoms`に変えてしまうと、初期画像そのものが変わってしまうのです。
+
+```
+girl in street shirt,bottoms daytime BREAK
+(forest printed:1.3) T-shirt ,shirt BREAK
+(red skirt:1.7) ,bottoms
+```
+で作った画像を三番目に置きました。  
+![5](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial5.png)   
+shortshortsのままで作成した場合はshortshorts周辺だけが変わっていますが、shortshortsをbottomsに変えた場合はベースが変わることになるので全体が変わってしまいます。つまり、プロンプト指定では一部だけを変更するインペイントのようなことができるというわけです。
+
+少し設定を変えて着せ替えてみましょう。`(shortshorts:0.5)`としているのは、skirtなどを優先するためです。領域用のshortshortsは弱めても問題ありません。普通は同じものを対象としますが、強い単語だと影響が出すぎてしまうので弱めるのも手です。
+
+```
+girl in street shirt,shortshorts daytime BREAK
+(forest printed:1.3) T-shirt ,shirt BREAK
+(red skirt:1.5) ,(shortshorts:0.5)
+```
+```
+Divide mode : Prompt
+Calcmode : Attention
+threshold : 0.7,0.55
+```
+`long skirt`などに対応するために`shortshorts`の`threshold`を広くしています。bottoms やlower bodyの方が楽だと思います。
+![6](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial6.png)  
+着せ替えできましたが、pinkは浸食が出ていますね。これは強度の指定を一括で行っているからで、設定を詰めれば浸食はなくなりはずです。
+
+さて次は背景を変えてみましょう。
+
+```
+girl in street shirt,shortshorts daytime BREAK
+(forest printed:1.3) T-shirt ,shirt BREAK
+(red skirt:1.5) ,(shortshorts:0.5) BREAK
+(Japan landscape:1.6),street
+```
+```
+Divide mode : Prompt
+Calcmode : Attention
+threshold : 0.7,0.55,0.7
+```
+Japanの部分を変えてみます。  
+![7](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial7.png)  
+landscapeという単語はなかなかくせ者で、この単語はかなり強いので他の単語の効果を打ち消すことが多々あるわけですが、landscapeの代わりにstreetで領域計算して適用することで強く出過ぎることを抑えることができるわけです。このように、別な単語で領域を計算するということで表現の幅が広がるのではないでしょうか。
+
+Regional Prompterを無効にするとこうなります。
+これはこれでいいですね。
+![8](https://github.com/hako-mikan/sd-webui-regional-prompter/blob/imgs/ptutorial8.png)    

regional-prompter-main/scripts/attention.py

@@ -0,0 +1,575 @@
+import math
+from pprint import pprint
+import ldm.modules.attention as atm
+import torch
+import torchvision
+import torchvision.transforms.functional as F
+from torchvision.transforms import InterpolationMode, Resize  # Mask.
+
+TOKENSCON = 77
+TOKENS = 75
+
+def db(self,text):
+    if self.debug:
+        print(text)
+
+def main_forward(module,x,context,mask,divide,isvanilla = False,userpp = False,tokens=[],width = 64,height = 64,step = 0, isxl = False, negpip = None):
+    
+    # Forward.
+
+    if negpip:
+        conds, contokens = negpip
+        context = torch.cat((context,conds),1)
+
+    h = module.heads
+    if isvanilla: # SBM Ddim / plms have the context split ahead along with x.
+        pass
+    else: # SBM I think divide may be redundant.
+        h = h // divide
+    q = module.to_q(x)
+
+    context = atm.default(context, x)
+    k = module.to_k(context)
+    v = module.to_v(context)
+
+    q, k, v = map(lambda t: atm.rearrange(t, 'b n (h d) -> (b h) n d', h=h), (q, k, v))
+
+    sim = atm.einsum('b i d, b j d -> b i j', q, k) * module.scale
+
+    if negpip:
+        conds, contokens = negpip
+        if contokens:
+            for contoken in contokens:
+                start = (v.shape[1]//77 - len(contokens)) * 77
+                v[:,start+1:start+contoken,:] = -v[:,start+1:start+contoken,:] 
+
+    if atm.exists(mask):
+        mask = atm.rearrange(mask, 'b ... -> b (...)')
+        max_neg_value = -torch.finfo(sim.dtype).max
+        mask = atm.repeat(mask, 'b j -> (b h) () j', h=h)
+        sim.masked_fill_(~mask, max_neg_value)
+
+    attn = sim.softmax(dim=-1)
+
+    ## for prompt mode make basemask from attention maps
+
+    global pmaskshw,pmasks
+
+    hiresscaler(height,width,attn)
+
+    if userpp and step > 0:
+        for b in range(attn.shape[0] // 8):
+            if pmaskshw == []:
+                pmaskshw = [(height,width)]
+            elif (height,width) not in pmaskshw:
+                pmaskshw.append((height,width))
+
+            for t in tokens:
+                power = 4 if isxl else 1.2
+                add = attn[8*b:8*(b+1),:,t[0]:t[0]+len(t)]**power
+                add = torch.sum(add,dim = 2)
+                t = f"{t}-{b}"         
+                if t not in pmasks:
+                    pmasks[t] = add
+                else:
+                    if pmasks[t].shape[1] != add.shape[1]:
+                        add = add.view(8,height,width)
+                        add = F.resize(add,pmaskshw[0])
+                        add = add.reshape_as(pmasks[t])
+
+                    pmasks[t] = pmasks[t] + add
+
+    out = atm.einsum('b i j, b j d -> b i d', attn, v)
+    out = atm.rearrange(out, '(b h) n d -> b n (h d)', h=h)
+    out = module.to_out(out)
+
+    return out
+
+def hook_forwards(self, root_module: torch.nn.Module, remove=False):
+    self.hooked = True if not remove else False
+    for name, module in root_module.named_modules():
+        if "attn2" in name and module.__class__.__name__ == "CrossAttention":
+            module.forward = hook_forward(self, module)
+            if remove:
+                del module.forward
+
+################################################################################
+##### Attention mode 
+
+def hook_forward(self, module):
+    def forward(x, context=None, mask=None, additional_tokens=None, n_times_crossframe_attn_in_self=0):
+        if self.debug :
+            print("input : ", x.size())
+            print("tokens : ", context.size())
+            print("module : ", getattr(module, self.layer_name,None))
+
+        if self.xsize == 0: self.xsize = x.shape[1]
+        if "input" in getattr(module, self.layer_name,""):
+            if x.shape[1] > self.xsize:
+                self.in_hr = True
+
+        height = self.hr_h if self.in_hr and self.hr else self.h 
+        width = self.hr_w if self.in_hr and self.hr else self.w
+
+        xs = x.size()[1]
+        scale = round(math.sqrt(height * width / xs))
+
+        dsh = round(height / scale)
+        dsw = round(width / scale)
+        ha, wa = xs % dsh, xs % dsw
+        if ha == 0:
+            dsw = int(xs / dsh)
+        elif wa == 0:
+            dsh = int(xs / dsw)
+
+        contexts = context.clone()
+
+        # SBM Matrix mode.
+        def matsepcalc(x,contexts,mask,pn,divide):
+            h_states = []
+            xs = x.size()[1]
+            (dsh,dsw) = split_dims(xs, height, width, self)
+            
+            if "Horizontal" in self.mode: # Map columns / rows first to outer / inner.
+                dsout = dsw
+                dsin = dsh
+            elif "Vertical" in self.mode:
+                dsout = dsh
+                dsin = dsw
+
+            tll = self.pt if pn else self.nt
+            
+            i = 0
+            outb = None
+            if self.usebase:
+                context = contexts[:,tll[i][0] * TOKENSCON:tll[i][1] * TOKENSCON,:]
+                # SBM Controlnet sends extra conds at the end of context, apply it to all regions.
+                cnet_ext = contexts.shape[1] - (contexts.shape[1] // TOKENSCON) * TOKENSCON
+                if cnet_ext > 0:
+                    context = torch.cat([context,contexts[:,-cnet_ext:,:]],dim = 1)
+                    
+                negpip = negpipdealer(i,pn)
+
+                i = i + 1
+
+                out = main_forward(module, x, context, mask, divide, self.isvanilla,userpp =True,step = self.step, isxl = self.isxl, negpip = negpip)
+
+                if len(self.nt) == 1 and not pn:
+                    db(self,"return out for NP")
+                    return out
+                # if self.usebase:
+                outb = out.clone()
+                outb = outb.reshape(outb.size()[0], dsh, dsw, outb.size()[2]) if "Ran" not in self.mode else outb
+
+            sumout = 0
+            db(self,f"tokens : {tll},pn : {pn}")
+            db(self,[r for r in self.aratios])
+
+            for drow in self.aratios:
+                v_states = []
+                sumin = 0
+                for dcell in drow.cols:
+                    # Grabs a set of tokens depending on number of unrelated breaks.
+                    context = contexts[:,tll[i][0] * TOKENSCON:tll[i][1] * TOKENSCON,:]
+                    # SBM Controlnet sends extra conds at the end of context, apply it to all regions.
+                    cnet_ext = contexts.shape[1] - (contexts.shape[1] // TOKENSCON) * TOKENSCON
+                    if cnet_ext > 0:
+                        context = torch.cat([context,contexts[:,-cnet_ext:,:]],dim = 1)
+                        
+                    negpip = negpipdealer(i,pn)
+
+                    db(self,f"tokens : {tll[i][0]*TOKENSCON}-{tll[i][1]*TOKENSCON}")
+                    i = i + 1 + dcell.breaks
+                    # if i >= contexts.size()[1]: 
+                    #     indlast = True
+
+                    out = main_forward(module, x, context, mask, divide, self.isvanilla,userpp = self.pn, step = self.step, isxl = self.isxl,negpip = negpip)
+                    db(self,f" dcell.breaks : {dcell.breaks}, dcell.ed : {dcell.ed}, dcell.st : {dcell.st}")
+                    if len(self.nt) == 1 and not pn:
+                        db(self,"return out for NP")
+                        return out
+                    # Actual matrix split by region.
+                    if "Ran" in self.mode:
+                        v_states.append(out)
+                        continue
+                    
+                    out = out.reshape(out.size()[0], dsh, dsw, out.size()[2]) # convert to main shape.
+                    # if indlast:
+                    addout = 0
+                    addin = 0
+                    sumin = sumin + int(dsin*dcell.ed) - int(dsin*dcell.st)
+                    if dcell.ed >= 0.999:
+                        addin = sumin - dsin
+                        sumout = sumout + int(dsout*drow.ed) - int(dsout*drow.st)
+                        if drow.ed >= 0.999:
+                            addout = sumout - dsout
+                    if "Horizontal" in self.mode:
+                        out = out[:,int(dsh*drow.st) + addout:int(dsh*drow.ed),
+                                    int(dsw*dcell.st) + addin:int(dsw*dcell.ed),:]
+                        if self.debug : print(f"{int(dsh*drow.st) + addout}:{int(dsh*drow.ed)},{int(dsw*dcell.st) + addin}:{int(dsw*dcell.ed)}")
+                        if self.usebase : 
+                            # outb_t = outb[:,:,int(dsw*drow.st):int(dsw*drow.ed),:].clone()
+                            outb_t = outb[:,int(dsh*drow.st) + addout:int(dsh*drow.ed),
+                                            int(dsw*dcell.st) + addin:int(dsw*dcell.ed),:].clone()
+                            out = out * (1 - dcell.base) + outb_t * dcell.base
+                    elif "Vertical" in self.mode: # Cols are the outer list, rows are cells.
+                        out = out[:,int(dsh*dcell.st) + addin:int(dsh*dcell.ed),
+                                  int(dsw*drow.st) + addout:int(dsw*drow.ed),:]
+                        db(self,f"{int(dsh*dcell.st) + addin}:{int(dsh*dcell.ed)}-{int(dsw*drow.st) + addout}:{int(dsw*drow.ed)}")
+                        if self.usebase : 
+                            # outb_t = outb[:,:,int(dsw*drow.st):int(dsw*drow.ed),:].clone()
+                            outb_t = outb[:,int(dsh*dcell.st) + addin:int(dsh*dcell.ed),
+                                          int(dsw*drow.st) + addout:int(dsw*drow.ed),:].clone()
+                            out = out * (1 - dcell.base) + outb_t * dcell.base
+                    db(self,f"sumin:{sumin},sumout:{sumout},dsh:{dsh},dsw:{dsw}")
+            
+                    v_states.append(out)
+                    if self.debug : 
+                        for h in v_states:
+                            print(h.size())
+                            
+                if "Horizontal" in self.mode:
+                    ox = torch.cat(v_states,dim = 2) # First concat the cells to rows.
+                elif "Vertical" in self.mode:
+                    ox = torch.cat(v_states,dim = 1) # Cols first mode, concat to cols.
+                elif "Ran" in self.mode:
+                    if self.usebase:
+                        ox = outb * makerrandman(self.ranbase,dsh,dsw).view(-1, 1)
+                    ox = torch.zeros_like(v_states[0])
+                    for state, filter in zip(v_states, self.ransors):
+                        filter = makerrandman(filter,dsh,dsw)
+                        ox = ox + state * filter.view(-1, 1)
+                    return ox
+
+                h_states.append(ox)
+            if "Horizontal" in self.mode:
+                ox = torch.cat(h_states,dim = 1) # Second, concat rows to layer.
+            elif "Vertical" in self.mode:
+                ox = torch.cat(h_states,dim = 2) # Or cols.
+            ox = ox.reshape(x.size()[0],x.size()[1],x.size()[2]) # Restore to 3d source.  
+            return ox
+
+        def masksepcalc(x,contexts,mask,pn,divide):
+            xs = x.size()[1]
+            (dsh,dsw) = split_dims(xs, height, width, self)
+
+            tll = self.pt if pn else self.nt
+            
+            # Base forward.
+            i = 0
+            outb = None
+            if self.usebase:
+                context = contexts[:,tll[i][0] * TOKENSCON:tll[i][1] * TOKENSCON,:]
+                # SBM Controlnet sends extra conds at the end of context, apply it to all regions.
+                cnet_ext = contexts.shape[1] - (contexts.shape[1] // TOKENSCON) * TOKENSCON
+                if cnet_ext > 0:
+                    context = torch.cat([context,contexts[:,-cnet_ext:,:]],dim = 1)
+
+                negpip = negpipdealer(i,pn) 
+
+                i = i + 1
+                out = main_forward(module, x, context, mask, divide, self.isvanilla, isxl = self.isxl, negpip = negpip)
+
+                if len(self.nt) == 1 and not pn:
+                    db(self,"return out for NP")
+                    return out
+                # if self.usebase:
+                outb = out.clone()
+                outb = outb.reshape(outb.size()[0], dsh, dsw, outb.size()[2]) 
+
+            db(self,f"tokens : {tll},pn : {pn}")
+            
+            ox = torch.zeros_like(x)
+            ox = ox.reshape(ox.shape[0], dsh, dsw, ox.shape[2])
+            ftrans = Resize((dsh, dsw), interpolation = InterpolationMode("nearest"))
+            for rmask in self.regmasks:
+                # Need to delay mask tensoring so it's on the correct gpu.
+                # Dunno if caching masks would be an improvement.
+                if self.usebase:
+                    bweight = self.bratios[0][i - 1]
+                # Resize mask to current dims.
+                # Since it's a mask, we prefer a binary value, nearest is the only option.
+                rmask2 = ftrans(rmask.reshape([1, *rmask.shape])) # Requires dimensions N,C,{d}.
+                rmask2 = rmask2.reshape(1, dsh, dsw, 1)
+                
+                # Grabs a set of tokens depending on number of unrelated breaks.
+                context = contexts[:,tll[i][0] * TOKENSCON:tll[i][1] * TOKENSCON,:]
+                # SBM Controlnet sends extra conds at the end of context, apply it to all regions.
+                cnet_ext = contexts.shape[1] - (contexts.shape[1] // TOKENSCON) * TOKENSCON
+                if cnet_ext > 0:
+                    context = torch.cat([context,contexts[:,-cnet_ext:,:]],dim = 1)
+                    
+                db(self,f"tokens : {tll[i][0]*TOKENSCON}-{tll[i][1]*TOKENSCON}")
+                i = i + 1
+                # if i >= contexts.size()[1]: 
+                #     indlast = True
+                out = main_forward(module, x, context, mask, divide, self.isvanilla, isxl = self.isxl)
+                if len(self.nt) == 1 and not pn:
+                    db(self,"return out for NP")
+                    return out
+                    
+                out = out.reshape(out.size()[0], dsh, dsw, out.size()[2]) # convert to main shape.
+                if self.usebase:
+                    out = out * (1 - bweight) + outb * bweight
+                ox = ox + out * rmask2
+
+            if self.usebase:
+                rmask = self.regbase
+                rmask2 = ftrans(rmask.reshape([1, *rmask.shape])) # Requires dimensions N,C,{d}.
+                rmask2 = rmask2.reshape(1, dsh, dsw, 1)
+                ox = ox + outb * rmask2
+            ox = ox.reshape(x.size()[0],x.size()[1],x.size()[2]) # Restore to 3d source.  
+            return ox
+
+        def promptsepcalc(x, contexts, mask, pn,divide):
+            h_states = []
+
+            tll = self.pt if pn else self.nt
+            db(self,f"tokens : {tll},pn : {pn}")
+
+            for i, tl in enumerate(tll):
+                context = contexts[:, tl[0] * TOKENSCON : tl[1] * TOKENSCON, :]
+                # SBM Controlnet sends extra conds at the end of context, apply it to all regions.
+                cnet_ext = contexts.shape[1] - (contexts.shape[1] // TOKENSCON) * TOKENSCON
+                if cnet_ext > 0:
+                    context = torch.cat([context,contexts[:,-cnet_ext:,:]],dim = 1)
+                
+                db(self,f"tokens : {tl[0]*TOKENSCON}-{tl[1]*TOKENSCON}")
+
+                userpp = self.pn and i == 0 and self.pfirst
+
+                negpip = negpipdealer(self.condi,pn) if "La" in self.calc else negpipdealer(i,pn)
+
+                out = main_forward(module, x, context, mask, divide, self.isvanilla, userpp = userpp, width = dsw, height = dsh, tokens = self.pe, step = self.step, isxl = self.isxl, negpip = negpip)
+
+                if (len(self.nt) == 1 and not pn) or ("Pro" in self.mode and "La" in self.calc):
+                    db(self,"return out for NP or Latent")
+                    return out
+
+                db(self,[scale, dsh, dsw, dsh * dsw, x.size()[1]])
+
+                if i == 0:
+                    outb = out.clone()
+                    continue
+                else:
+                    h_states.append(out)
+
+            if self.debug:
+                for h in h_states :
+                    print(f"divided : {h.size()}")
+                print(pmaskshw)
+
+            if pmaskshw == []:
+                return outb
+
+            ox = outb.clone() if self.ex else outb * 0
+
+            db(self,[pmaskshw,maskready,(dsh,dsw) in pmaskshw and maskready,len(pmasksf),len(h_states)])
+
+            if (dsh,dsw) in pmaskshw and maskready:
+                depth = pmaskshw.index((dsh,dsw))
+                maskb = None
+                for masks , state in zip(pmasksf.values(),h_states):
+                    mask = masks[depth]
+                    masked = torch.multiply(state, mask)
+                    if self.ex:
+                        ox = torch.where(masked !=0 , masked, ox)
+                    else:
+                        ox = ox + masked
+                    maskb = maskb + mask if maskb is not None else mask
+                maskb = 1 - maskb
+                if not self.ex : ox = ox + torch.multiply(outb, maskb)
+                return ox
+            else:
+                return outb
+
+        if self.eq:
+            db(self,"same token size and divisions")
+            if "Mas" in self.mode:
+                ox = masksepcalc(x, contexts, mask, True, 1)
+            elif "Pro" in self.mode:
+                ox = promptsepcalc(x, contexts, mask, True, 1)
+            else:
+                ox = matsepcalc(x, contexts, mask, True, 1)
+        elif x.size()[0] == 1 * self.batch_size:
+            db(self,"different tokens size")
+            if "Mas" in self.mode:
+                ox = masksepcalc(x, contexts, mask, self.pn, 1)
+            elif "Pro" in self.mode:
+                ox = promptsepcalc(x, contexts, mask, self.pn, 1)
+            else:
+                ox = matsepcalc(x, contexts, mask, self.pn, 1)
+        else:
+            db(self,"same token size and different divisions")
+            # SBM You get 2 layers of x, context for pos/neg.
+            # Each should be forwarded separately, pairing them up together.
+            if self.isvanilla: # SBM Ddim reverses cond/uncond.
+                nx, px = x.chunk(2)
+                conn,conp = contexts.chunk(2)
+            else:
+                px, nx = x.chunk(2)
+                conp,conn = contexts.chunk(2)
+            if "Mas" in self.mode:
+                opx = masksepcalc(px, conp, mask, True, 2)
+                onx = masksepcalc(nx, conn, mask, False, 2)
+            elif "Pro" in self.mode:
+                opx = promptsepcalc(px, conp, mask, True, 2)
+                onx = promptsepcalc(nx, conn, mask, False, 2)
+            else:
+                # SBM I think division may have been an incorrect patch.
+                # But I'm not sure, haven't tested beyond DDIM / PLMS.
+                opx = matsepcalc(px, conp, mask, True, 2)
+                onx = matsepcalc(nx, conn, mask, False, 2)
+            if self.isvanilla: # SBM Ddim reverses cond/uncond.
+                ox = torch.cat([onx, opx])
+            else:
+                ox = torch.cat([opx, onx])  
+
+        self.count += 1
+
+        limit = 70 if self.isxl else 16
+
+        if self.count == limit:
+            self.pn = not self.pn
+            self.count = 0
+            self.pfirst = False
+            self.condi += 1
+        db(self,f"output : {ox.size()}")
+        return ox
+
+    return forward
+
+def split_dims(xs, height, width, self):
+    """Split an attention layer dimension to height + width.
+    
+    Originally, the estimate was dsh = sqrt(hw_ratio*xs),
+    rounding to the nearest value. But this proved inaccurate.
+    What seems to be the actual operation is as follows:
+    - Divide h,w by 8, rounding DOWN. 
+      (However, webui forces dims to be divisible by 8 unless set explicitly.)
+    - For every new layer (of 4), divide both by 2 and round UP (then back up)
+    - Multiply h*w to yield xs.
+    There is no inverse function to this set of operations,
+    so instead we mimic them sans the multiplication part with orig h+w.
+    The only alternative is brute forcing integer guesses,
+    which might be inaccurate too.
+    No known checkpoints follow a different system of layering,
+    but it's theoretically possible. Please report if encountered.
+    """
+    # OLD METHOD.
+    # scale = round(math.sqrt(height*width/xs))
+    # dsh = round_dim(height, scale)
+    # dsw = round_dim(width, scale) 
+    scale = math.ceil(math.log2(math.sqrt(height * width / xs)))
+    dsh = repeat_div(height,scale)
+    dsw = repeat_div(width,scale)
+    if xs > dsh * dsw and hasattr(self,"nei_multi"):
+        dsh, dsw = self.nei_multi[1], self.nei_multi[0] 
+        while dsh*dsw != xs:
+            dsh, dsw = dsh//2, dsw//2
+
+    if self.debug : print(scale,dsh,dsw,dsh*dsw,xs, height, width)
+
+    return dsh,dsw
+
+def repeat_div(x,y):
+    """Imitates dimension halving common in convolution operations.
+    
+    This is a pretty big assumption of the model,
+    but then if some model doesn't work like that it will be easy to spot.
+    """
+    while y > 0:
+        x = math.ceil(x / 2)
+        y = y - 1
+    return x
+
+#################################################################################
+##### for Prompt mode
+pmasks = {}              #maked from attention maps
+pmaskshw =[]            #height,width set of u-net blocks
+pmasksf = {}             #maked from pmasks for regions
+maskready = False
+
+def reset_pmasks(self): # init parameters in every batch
+    global pmasks, pmaskshw, pmasksf, maskready
+    self.step = 0
+    pmasks = {}
+    pmaskshw =[]
+    pmasksf = {}
+    maskready = False
+    self.x = None
+    self.rebacked = False
+
+def savepmasks(self,processed):
+    for mask ,th in zip(pmasks.values(),self.th):
+        img, _ , _= makepmask(mask, self.h, self.w,th, self.step)
+        processed.images.append(img)
+    return processed
+
+def hiresscaler(height,width,attn):
+    global pmaskshw,pmasks,pmasksf
+    if pmaskshw != []:
+        if height > pmaskshw[0][0]: # [0][0] has largest height, if in hires, height will be larger than [0][0]
+            (oh, ow) = pmaskshw[0]
+            del pmaskshw
+            pmaskshw = [(height,width)]
+            hiresmask(pmasks,oh, ow, height, width,attn[:,:,0])
+            for i in range(4):
+                m = (2 ** (i))
+                hiresmask(pmasksf,oh//m, ow//m, height//m,width//m ,torch.zeros(1,height*width //m**2,1),i = i )
+
+def hiresmask(masks,oh,ow,nh,nw,at,i = None):
+    for key in masks.keys():
+        mask = masks[key] if i is None else masks[key][i]
+        mask = mask.view(8 if i is None else 1,oh,ow)
+        mask = F.resize(mask,(nh,nw))
+        mask = mask.reshape_as(at)
+        if i is None:
+            masks[key] = mask
+        else:
+            masks[key][i] = mask
+
+def makepmask(mask, h, w, th, step, bratio = 1): # make masks from attention cache return [for preview, for attention, for Latent]
+    th = th - step * 0.005
+    bratio = 1 - bratio
+    mask = torch.mean(mask,dim=0)
+    mask = mask / mask.max().item()
+    mask = torch.where(mask > th ,1,0)
+    mask = mask.float()
+    mask = mask.view(1,pmaskshw[0][0],pmaskshw[0][1]) 
+    img = torchvision.transforms.functional.to_pil_image(mask)
+    img = img.resize((w,h))
+    mask = F.resize(mask,(h,w),interpolation=F.InterpolationMode.NEAREST)
+    lmask = mask
+    mask = mask.reshape(h*w)
+    mask = torch.where(mask > 0.1 ,1,0)
+    return img,mask * bratio , lmask * bratio
+
+def makerrandman(mask, h, w, latent = False): # make masks from attention cache return [for preview, for attention, for Latent]
+    mask = mask.float()
+    mask = mask.view(1,mask.shape[0],mask.shape[1]) 
+    img = torchvision.transforms.functional.to_pil_image(mask)
+    img = img.resize((w,h))
+    mask = F.resize(mask,(h,w),interpolation=F.InterpolationMode.NEAREST)
+    if latent: return mask
+    mask = mask.reshape(h*w)
+    mask = torch.round(mask).long()
+    return mask
+
+def negpipdealer(i,pn):
+    negpip = None
+    from modules.scripts import scripts_txt2img
+    for script in scripts_txt2img.alwayson_scripts:
+        if "negpip.py" in script.filename:
+            negpip = script
+
+    if negpip:
+        conds = negpip.conds if pn else negpip.unconds
+        tokens = negpip.contokens if pn else negpip.untokens
+        if conds and len(conds) >= i + 1:
+            if conds[i] is not None:
+                return [conds[i],tokens[i]]
+        else:
+            return None
+    else:
+        return None

regional-prompter-main/scripts/latent.py

@@ -0,0 +1,534 @@
+from difflib import restore
+import random
+import copy
+from pprint import pprint
+import re
+from typing import Union
+import torch
+from modules import devices, shared, extra_networks
+from modules.script_callbacks import CFGDenoisedParams, CFGDenoiserParams
+from torchvision.transforms import InterpolationMode, Resize  # Mask.
+import scripts.attention as att
+from scripts.regions import floatdef
+from scripts.attention import makerrandman
+
+islora = True
+in_hr = False
+layer_name = "lora_layer_name"
+orig_Linear_forward = None
+orig_lora_functional = False
+lactive = False
+labug =False
+MINID = 1000
+MAXID = 10000
+LORAID = MINID # Discriminator for repeated lora usage / across gens, presumably.
+
+def setloradevice(self):
+    global LORAID
+    regioner.__init__()
+    import lora
+    if self.debug : print("change LoRA device for new lora")
+    self.log["lora_apply_weights"] = hasattr(lora,"lora_apply_weights")
+    
+    if hasattr(lora,"lora_apply_weights") or not self.isbefore15: # for new LoRA applying
+        oldnew =[]
+        for l in lora.loaded_loras:
+            LORAID = LORAID + 1
+            if LORAID > MAXID:
+                LORAID = MINID
+            old = l.name
+            new = l.name = l.name + "_in_RP" + str(LORAID)
+            oldnew.append([old,new])
+
+            for key in l.modules.keys():
+                changethedevice(l.modules[key])
+    
+    if regioner.ctl:
+        import lora_ctl_network as ctl
+        for old,new in oldnew:
+            if old in ctl.lora_weights.keys():
+                ctl.lora_weights[new] = ctl.lora_weights[old]
+
+def setuploras(self):
+    global lactive, labug, islora, orig_Linear_forward, orig_lora_functional, layer_name
+    lactive = True
+    labug = self.debug
+    islora = self.isbefore15
+    layer_name = self.layer_name
+    orig_lora_functional = shared.opts.lora_functional
+
+    if 150 <= self.ui_version <= 159:
+        shared.opts.lora_functional = False
+    else:
+        shared.opts.lora_functional = True
+    orig_Linear_forward = torch.nn.Linear.forward
+    torch.nn.Linear.forward = h_Linear_forward
+
+def cloneparams(orig,target):
+    target.x = orig.x.clone()
+    target.image_cond  = orig.image_cond.clone()
+    target.sigma  = orig.sigma.clone()
+
+###################################################
+###### Latent Method denoise call back
+# Using the AND syntax with shared.batch_cond_uncond = False
+# the U-NET is calculated (the number of prompts divided by AND) + 1 times.
+# This means that the calculation is performed for the area + 1 times.
+# This mechanism is used to apply LoRA by region by changing the LoRA application rate for each U-NET calculation.
+# The problem here is that in the web-ui system, if more than two batch sizes are set, 
+# a problem will occur if the number of areas and the batch size are not the same.
+# If the batch is 1 for 3 areas, the calculation is performed 4 times: Area1, Area2, Area3, and Negative. 
+# However, if the batch is 2, 
+# [Batch1-Area1, Batch1-Area2]
+# [Batch1-Area3, Batch2-Area1]
+# [Batch2-Area2, Batch2-Area3]
+# [Batch1-Negative, Batch2-Negative]
+# and the areas of simultaneous computation will be different. 
+# Therefore, it is necessary to change the order in advance.
+# [Batch1-Area1, Batch1-Area2] -> [Batch1-Area1, Batch2-Area1] 
+# [Batch1-Area3, Batch2-Area1] -> [Batch1-Area2, Batch2-Area2] 
+# [Batch2-Area2, Batch2-Area3] -> [Batch1-Area3, Batch2-Area3] 
+
+def denoiser_callback_s(self, params: CFGDenoiserParams):
+    if "Pro" in self.mode:  # in Prompt mode, make masks from sum of attension maps
+        if self.x == None : cloneparams(params,self) # return to step 0 if mask is ready
+        self.step = params.sampling_step
+        self.pfirst = True
+
+        lim = 1 if self.isxl else 3
+
+        if len(att.pmaskshw) > lim:
+            if "La" in self.calc:
+                self.filters = []
+                for b in range(self.batch_size):
+
+                    allmask = []
+                    basemask = None
+                    for t, th, bratio in zip(self.pe, self.th, self.bratios):
+                        key = f"{t}-{b}"
+                        _, _, mask = att.makepmask(att.pmasks[key], params.x.shape[2], params.x.shape[3], th, self.step, bratio = bratio)
+                        mask = mask.repeat(params.x.shape[1],1,1)
+                        basemask = 1 - mask if basemask is None else basemask - mask
+                        if self.ex:
+                            for l in range(len(allmask)):
+                                mt = allmask[l] - mask
+                                allmask[l] = torch.where(mt > 0, 1,0)
+                        allmask.append(mask)
+                    if not self.ex:
+                        sum = torch.stack(allmask, dim=0).sum(dim=0)
+                        sum = torch.where(sum == 0, 1 , sum)
+                        allmask = [mask  / sum for mask in allmask]
+                    basemask = torch.where(basemask > 0, 1, 0)
+                    allmask.insert(0,basemask)
+                    self.filters.extend(allmask)
+                att.maskready = True
+            else:    
+                for t, th, bratio in zip(self.pe, self.th, self.bratios):
+                    allmask = []
+                    for hw in att.pmaskshw:
+                        masks = None
+                        for b in range(self.batch_size):
+                            key = f"{t}-{b}"
+                            _, mask, _ = att.makepmask(att.pmasks[key], hw[0], hw[1], th, self.step, bratio = bratio)
+                            mask = mask.unsqueeze(0).unsqueeze(-1)
+                            masks = mask if b ==0 else torch.cat((masks,mask),dim=0)
+                        allmask.append(mask)     
+                    att.pmasksf[key] = allmask
+                    att.maskready = True
+
+            if not self.rebacked: 
+                cloneparams(self,params)
+                self.rebacked = True
+
+    if "La" in self.calc:
+        self.condi = 0
+        global in_hr, regioner
+        regioner.step = params.sampling_step
+        in_hr = self.in_hr
+        regioner.u_count = 0
+        if "u_list" not in self.log.keys() and hasattr(regioner,"u_llist"):
+            self.log["u_list"] = regioner.u_llist.copy()
+        if "u_list_hr" not in self.log.keys() and hasattr(regioner,"u_llist") and in_hr:
+            self.log["u_list_hr"] = regioner.u_llist.copy()
+        xt = params.x.clone()
+        ict = params.image_cond.clone()
+        st =  params.sigma.clone()
+        batch = self.batch_size
+        areas = xt.shape[0] // batch -1
+        # SBM Stale version workaround.
+        if hasattr(params,"text_cond"):
+            if "DictWithShape" in params.text_cond.__class__.__name__:
+                ct = {}
+                for key in params.text_cond.keys():
+                    ct[key] = params.text_cond[key].clone()
+            else:
+                ct =  params.text_cond.clone()
+
+        for a in range(areas):
+            for b in range(batch):
+                params.x[b+a*batch] = xt[a + b * areas]
+                params.image_cond[b+a*batch] = ict[a + b * areas]
+                params.sigma[b+a*batch] = st[a + b * areas]
+                # SBM Stale version workaround.
+                if hasattr(params,"text_cond"):
+                    if "DictWithShape" in params.text_cond.__class__.__name__:
+                        for key in params.text_cond.keys():
+                            params.text_cond[key][b+a*batch] = ct[key][a + b * areas]
+                    else:
+                        params.text_cond[b+a*batch] = ct[a + b * areas]
+
+def denoised_callback_s(self, params: CFGDenoisedParams):
+    if "La" in self.calc:
+        x = params.x
+        xt = params.x.clone()
+        batch = self.batch_size
+        areas = xt.shape[0] // batch -1
+
+        # x.shape = [batch_size, C, H // 8, W // 8]
+
+        if not "Pro" in self.mode:
+            indrebuild = self.filters == [] or self.filters[0].size() != x[0].size()
+
+            if indrebuild:
+                if "Ran" in self.mode:
+                    if self.filters == []:
+                        self.filters = [self.ranbase] + self.ransors if self.usebase else self.ransors
+                    elif self.filters[0][:,:].size() != x[0,0,:,:].size():
+                        self.filters = hrchange(self.ransors,x.shape[2], x.shape[3])
+                else:
+                    if "Mask" in self.mode:
+                        masks = (self.regmasks,self.regbase)
+                    else:
+                        masks = self.aratios  #makefilters(c,h,w,masks,mode,usebase,bratios,indmask = None)
+                    self.filters = makefilters(x.shape[1], x.shape[2], x.shape[3],masks, self.mode, self.usebase, self.bratios, "Mas" in self.mode)
+                self.filters = [f for f in self.filters]*batch
+        else:
+            if not att.maskready:
+                self.filters = [1,*[0 for a in range(areas - 1)]] * batch
+
+        if self.debug : print("filterlength : ",len(self.filters))
+
+        for b in range(batch):
+            for a in range(areas) :
+                fil = self.filters[a + b*areas]
+                if self.debug : print(f"x = {x.size()}i = {a + b*areas}, j = {b + a*batch}, cond = {a + b*areas},filsum = {fil if type(fil) is int else torch.sum(fil)}, uncon = {x.size()[0]+(b-batch)}")
+                x[a + b * areas, :, :, :] =  xt[b + a*batch, :, :, :] * fil + x[x.size()[0]+(b-batch), :, :, :] * (1 - fil)
+
+######################################################
+##### Latent Method
+
+def hrchange(filters,h, w):
+    out = []
+    for filter in filters:
+        out.append(makerrandman(filter,h,w,True))
+    return out
+
+# Remove tags from called lora names.
+flokey = lambda x: (x.split("added_by_regional_prompter")[0]
+                    .split("added_by_lora_block_weight")[0].split("_in_LBW")[0].split("_in_RP")[0])
+
+def lora_namer(self, p, lnter, lnur):
+    ldict_u = {}
+    ldict_te = {}
+    lorder = [] # Loras call order for matching with u/te lists.
+    import lora as loraclass
+    for lora in loraclass.loaded_loras:
+        ldict_u[lora.name] =lora.multiplier if self.isbefore15 else lora.unet_multiplier
+        ldict_te[lora.name] =lora.multiplier  if self.isbefore15 else lora.te_multiplier
+    
+    subprompts = self.current_prompts[0].split("AND")
+    ldictlist_u =[ldict_u.copy() for i in range(len(subprompts)+1)]
+    ldictlist_te =[ldict_te.copy() for i in range(len(subprompts)+1)]
+
+    for i, prompt in enumerate(subprompts):
+        _, extranets = extra_networks.parse_prompts([prompt])
+        calledloras = extranets["lora"]
+
+        names = ""
+        tdict = {}
+
+        for called in calledloras:
+            names = names + called.items[0]
+            tdict[called.items[0]] = syntaxdealer(called.items,"unet=",1)
+
+        for key in ldictlist_u[i].keys():
+            shin_key = flokey(key)
+            if shin_key in names:
+                ldictlist_u[i+1][key] = float(tdict[shin_key])
+                ldictlist_te[i+1][key] = float(tdict[shin_key])
+                if key not in lorder:
+                    lorder.append(key)
+            else:
+                ldictlist_u[i+1][key] = 0
+                ldictlist_te[i+1][key] = 0
+                
+    if self.debug: print("Regioner lorder: ",lorder)
+    global regioner
+    regioner.__init__(self.lstop,self.lstop_hr)
+    u_llist = [d.copy() for d in ldictlist_u[1:]]
+    u_llist.append(ldictlist_u[0].copy())
+    regioner.te_llist = ldictlist_te
+    regioner.u_llist = u_llist
+    regioner.ndeleter(lnter, lnur, lorder)
+    if self.debug:
+        print("LoRA regioner : TE list",regioner.te_llist)
+        print("LoRA regioner : U list",regioner.u_llist)
+
+def syntaxdealer(items,type,index): #type "unet=", "x=", "lwbe=" 
+    for item in items:
+        if type in item:
+            if "@" in item:return 1 #for loractl
+            return item.replace(type,"")
+    return items[index] if "@" not in items[index] else 1
+
+def makefilters(c,h,w,masks,mode,usebase,bratios,indmask):
+    if indmask:
+        (regmasks, regbase) = masks
+        
+    filters = []
+    x =  torch.zeros(c, h, w).to(devices.device)
+    if usebase:
+        x0 = torch.zeros(c, h, w).to(devices.device)
+    i=0
+    if indmask:
+        ftrans = Resize((h, w), interpolation = InterpolationMode("nearest"))
+        for rmask, bratio in zip(regmasks,bratios[0]):
+            # Resize mask to current dims.
+            # Since it's a mask, we prefer a binary value, nearest is the only option.
+            rmask2 = ftrans(rmask.reshape([1, *rmask.shape])) # Requires dimensions N,C,{d}.
+            rmask2 = rmask2.reshape([1, h, w])
+            fx = x.clone()
+            if usebase:
+                fx[:,:,:] = fx + rmask2 * (1 - bratio)
+                x0[:,:,:] = x0 + rmask2 * bratio
+            else:
+                fx[:,:,:] = fx + rmask2 * 1
+            filters.append(fx)
+            
+        if usebase: # Add base to x0.
+            rmask = regbase
+            rmask2 = ftrans(rmask.reshape([1, *rmask.shape])) # Requires dimensions N,C,{d}.
+            rmask2 = rmask2.reshape([1, h, w])
+            x0 = x0 + rmask2
+    else:
+        for drow in masks:
+            for dcell in drow.cols:
+                fx = x.clone()
+                if "Horizontal" in mode:
+                    if usebase:
+                        fx[:,int(h*drow.st):int(h*drow.ed),int(w*dcell.st):int(w*dcell.ed)] = 1 - dcell.base
+                        x0[:,int(h*drow.st):int(h*drow.ed),int(w*dcell.st):int(w*dcell.ed)] = dcell.base
+                    else:
+                        fx[:,int(h*drow.st):int(h*drow.ed),int(w*dcell.st):int(w*dcell.ed)] = 1    
+                elif "Vertical" in mode: 
+                    if usebase:
+                        fx[:,int(h*dcell.st):int(h*dcell.ed),int(w*drow.st):int(w*drow.ed)] = 1 - dcell.base
+                        x0[:,int(h*dcell.st):int(h*dcell.ed),int(w*drow.st):int(w*drow.ed)] = dcell.base
+                    else:
+                        fx[:,int(h*dcell.st):int(h*dcell.ed),int(w*drow.st):int(w*drow.ed)] = 1  
+                filters.append(fx)
+                i +=1
+    if usebase : filters.insert(0,x0)
+    if labug : print(i,len(filters))
+
+    return filters
+
+######################################################
+##### Latent Method LoRA changer
+
+TE_START_NAME = "transformer_text_model_encoder_layers_0_self_attn_q_proj"
+UNET_START_NAME = "diffusion_model_time_embed_0"
+
+TE_START_NAME_XL = "0_transformer_text_model_encoder_layers_0_self_attn_q_proj"
+
+class LoRARegioner:
+
+    def __init__(self,stop=0,stop_hr=0):
+        self.te_count = 0
+        self.u_count = 0
+        self.te_llist = [{}]
+        self.u_llist = [{}]
+        self.mlist = {}
+        self.ctl = False
+        self.step = 0
+        self.stop = stop
+        self.stop_hr = stop_hr
+
+        try:
+            import lora_ctl_network as ctl
+            self.ctlweight = copy.deepcopy(ctl.lora_weights)
+            for set in self.ctlweight.values():
+                for weight in set.values():
+                    if type(weight) == list:
+                        self.ctl = True        
+        except:
+            pass
+
+    def expand_del(self, val, lorder):
+        """Broadcast single / comma separated val to lora list. 
+        
+        """
+        lval = val.split(",")
+        if len(lval) > len(lorder):
+            lval = lval[:len(lorder)]
+        lval = [floatdef(v, 0) for v in lval]
+        if len(lval) < len(lorder): # Propagate difference.
+            lval.extend([lval[-1]] * (len(lorder) - len(lval)))
+        return lval
+
+    def ndeleter(self, lnter, lnur, lorder = None):
+        """Multiply global weights by 0:1 factor.
+        
+        Can be any value, negative too, but doesn't help much.
+        """
+        if lorder is None:
+            lkeys = self.te_llist[0].keys()
+        else:
+            lkeys = lorder
+        lnter = self.expand_del(lnter, lkeys)
+        for (key, val) in zip(lkeys, lnter):
+            self.te_llist[0][key] *= val
+        if lorder is None:
+            lkeys = self.u_llist[-1].keys()
+        else:
+            lkeys = lorder
+        lnur = self.expand_del(lnur, lkeys)
+        for (key, val) in zip(lkeys, lnur):
+            self.u_llist[-1][key] *= val
+
+    def search_key(self,lora,i,xlist):
+        lorakey = lora.loaded_loras[i].name
+        if lorakey not in xlist.keys():
+            shin_key = flokey(lorakey)
+            picked = False
+            for mlkey in xlist.keys():
+                if mlkey.startswith(shin_key):
+                    lorakey = mlkey
+                    picked = True
+            if not picked:
+                print(f"key is not found in:{xlist.keys()}")
+        return lorakey
+
+    def te_start(self):
+        self.mlist = self.te_llist[self.te_count % len(self.te_llist)]
+        self.te_count += 1
+        import lora
+        for i in range(len(lora.loaded_loras)):
+            lorakey = self.search_key(lora,i,self.mlist)
+            lora.loaded_loras[i].multiplier = self.mlist[lorakey]
+            lora.loaded_loras[i].te_multiplier = self.mlist[lorakey]
+
+    def u_start(self):
+        if labug : print("u_count",self.u_count ,"u_count '%' divide",  self.u_count % len(self.u_llist))
+        self.mlist = self.u_llist[self.u_count % len(self.u_llist)]
+        self.u_count  += 1
+
+        stopstep = self.stop_hr if in_hr else self.stop
+
+        import lora
+        for i in range(len(lora.loaded_loras)):
+            lorakey = self.search_key(lora,i,self.mlist)
+            lora.loaded_loras[i].multiplier = 0 if self.step + 2 > stopstep and stopstep else self.mlist[lorakey]
+            lora.loaded_loras[i].unet_multiplier = 0 if self.step + 2 > stopstep and stopstep else self.mlist[lorakey]
+            if labug :print(lorakey,lora.loaded_loras[i].multiplier,lora.loaded_loras[i].multiplier ) 
+            if self.ctl:
+                import lora_ctl_network as ctl
+                key = "hrunet" if in_hr else "unet"
+                if self.mlist[lorakey] == 0 or (self.step + 2 > stopstep and stopstep):
+                    ctl.lora_weights[lorakey][key] = [[0],[0]]
+                    if labug :print(ctl.lora_weights[lorakey])
+                else:
+                    if key in self.ctlweight[lorakey].keys():
+                        ctl.lora_weights[lorakey][key] = self.ctlweight[lorakey][key]
+                    else:
+                        ctl.lora_weights[lorakey][key] = self.ctlweight[lorakey]["unet"]
+                    if labug :print(ctl.lora_weights[lorakey])
+
+    def reset(self):
+        self.te_count = 0
+        self.u_count = 0
+    
+regioner = LoRARegioner()
+
+############################################################
+##### for new lora apply method in web-ui
+
+def h_Linear_forward(self, input):
+    changethelora(getattr(self, layer_name, None))
+    if islora:
+        import lora
+        return lora.lora_forward(self, input, torch.nn.Linear_forward_before_lora)
+    else:
+        import networks
+        if shared.opts.lora_functional:
+            return networks.network_forward(self, input, networks.originals.Linear_forward)
+        networks.network_apply_weights(self)
+        return torch.nn.Linear_forward_before_network(self, input)
+
+def changethelora(name):
+    if lactive:
+        global regioner
+        if name == TE_START_NAME or name == TE_START_NAME_XL:
+            regioner.te_start()
+        elif name == UNET_START_NAME:
+            regioner.u_start()
+
+LORAANDSOON = {
+    "IA3Module" : "w",
+    "LoraKronModule" : "w1",
+    "LycoKronModule" : "w1",
+}
+
+def changethedevice(module):
+    ltype = type(module).__name__
+    if ltype == "LoraUpDownModule" or ltype == "LycoUpDownModule" :
+        if hasattr(module,"up_model") :
+            module.up_model.weight = torch.nn.Parameter(module.up_model.weight.to(devices.device, dtype = torch.float))
+            module.down_model.weight = torch.nn.Parameter(module.down_model.weight.to(devices.device, dtype=torch.float))
+        else:
+            module.up.weight = torch.nn.Parameter(module.up.weight.to(devices.device, dtype = torch.float))
+            if hasattr(module.down, "weight"):
+                module.down.weight = torch.nn.Parameter(module.down.weight.to(devices.device, dtype=torch.float))
+        
+    elif ltype == "LoraHadaModule" or ltype == "LycoHadaModule":
+        module.w1a = torch.nn.Parameter(module.w1a.to(devices.device, dtype=torch.float))
+        module.w1b = torch.nn.Parameter(module.w1b.to(devices.device, dtype=torch.float))
+        module.w2a = torch.nn.Parameter(module.w2a.to(devices.device, dtype=torch.float))
+        module.w2b = torch.nn.Parameter(module.w2b.to(devices.device, dtype=torch.float))
+        
+        if module.t1 is not None:
+            module.t1 = torch.nn.Parameter(module.t1.to(devices.device, dtype=torch.float))
+
+        if module.t2 is not None:
+            module.t2 = torch.nn.Parameter(module.t2.to(devices.device, dtype=torch.float))
+        
+    elif ltype == "FullModule":
+        module.weight = torch.nn.Parameter(module.weight.to(devices.device, dtype=torch.float))
+    
+    if hasattr(module, 'bias') and module.bias != None:
+        module.bias = torch.nn.Parameter(module.bias.to(devices.device, dtype=torch.float))
+
+
+def restoremodel(p):
+    model = p.sd_model
+    for name, module in model.named_modules():
+        if hasattr(module, "lora_weights_backup"):
+            if module.lora_weights_backup is not None:
+                if isinstance(module, torch.nn.MultiheadAttention):
+                    module.in_proj_weight.copy_(module.lora_weights_backup[0])
+                    module.out_proj.weight.copy_(module.lora_weights_backup[1])
+                else:
+                    module.weight.copy_(module.lora_weights_backup)
+                module.lora_weights_backup = None
+                module.lora_current_names = None
+
+def unloadlorafowards(p):
+    global orig_Linear_forward, lactive, labug
+    lactive = labug = False
+    shared.opts.lora_functional =  orig_lora_functional
+
+    import lora
+    lora.loaded_loras.clear()
+    if orig_Linear_forward != None :
+        torch.nn.Linear.forward = orig_Linear_forward
+        orig_Linear_forward = None

regional-prompter-main/scripts/regions.py

@@ -0,0 +1,831 @@
+import colorsys  # Polygon regions.
+from pprint import pprint
+import cv2  # Polygon regions.
+import gradio as gr
+import numpy as np
+import PIL
+import torch
+from modules import devices
+
+def lange(l):
+    return range(len(l))
+
+# SBM Keywords and delimiters for region breaks, following matlab rules.
+# BREAK keyword is now passed through,  
+KEYROW = "ADDROW"
+KEYCOL = "ADDCOL"
+KEYBASE = "ADDBASE"
+KEYCOMM = "ADDCOMM"
+KEYBRK = "BREAK"
+KEYPROMPT = "ADDP"
+DELIMROW = ";"
+DELIMCOL = ","
+MCOLOUR = 256
+NLN = "\n"
+DKEYINOUT = { # Out/in, horizontal/vertical or row/col first.
+("out",False): KEYROW,
+("in",False): KEYCOL,
+("out",True): KEYCOL,
+("in",True): KEYROW,
+}
+
+ALLKEYS = [KEYCOMM,KEYROW, KEYCOL, KEYBASE, KEYPROMPT]
+ALLALLKEYS = [KEYCOMM,KEYROW, KEYCOL, KEYBASE, KEYPROMPT, KEYBRK, "AND"]
+
+fidentity = lambda x: x
+ffloatd = lambda c: (lambda x: floatdef(x,c))
+fcolourise = lambda: np.random.randint(0,MCOLOUR,size = 3)
+fspace = lambda x: " {} ".format(x)
+
+"""
+SBM mod: Two dimensional regions (of variable size, NOT a matrix).
+- Adds keywords ADDROW, ADDCOL and respective delimiters for aratios.
+- A/bratios become list dicts: Inner dict of cols (varying length list) + start/end + number of breaks,
+  outer layer is rows list.
+  First value in each row is the row's ratio, the rest are col ratios.
+  This fits prompts going left -> right, top -> down. 
+- Unrelated BREAKS are counted per cell, and later extracted as multiple context indices.
+- Each layer is cut up by both row + col ratios.
+- Style improvements: Created classes for rows + cells and functions for some of the splitting.
+- Base prompt overhaul: Added keyword ADDBASE, when present will trigger "use_base" automatically;
+  base is excluded from the main prompt for dim calcs; returned to start before hook (+ base break count);
+  during hook, context index skips base break count + 1. Rest is applied normally.
+- To specify cols first, use "vertical" mode. eg 1st col:2 rows, 2nd col:1 row.
+  In effect, this merely reverses the order of iteration for every row/col loop and whatnot.
+"""
+
+class RegionCell():
+    """Cell used to split a layer to single prompts."""
+    def __init__(self, st, ed, base, breaks):
+        """Range with start and end values, base weight and breaks count for context splitting."""
+        self.st = st # Range for the cell (cols only).
+        self.ed = ed
+        self.base = base # How much of the base prompt is applied (difference).
+        self.breaks = breaks # How many unrelated breaks the prompt contains.
+        
+    def __repr__(self):
+        """Debug print."""
+        return "({:.2f}:{:.2f})".format(self.st,self.ed) 
+        
+class RegionRow():
+    """Row containing cell refs and its own ratio range."""
+    def __init__(self, st, ed, cols):
+        """Range with start and end values, base weight and breaks count for context splitting."""
+        self.st = st # Range for the row.
+        self.ed = ed
+        self.cols = cols # List of cells.
+        
+    def __repr__(self):
+        """Debug print."""
+        return "Outer ({:.2f}:{:.2f}), contains {}".format(self.st, self.ed, self.cols) + NLN
+
+def floatdef(x, vdef):
+    """Attempt conversion to float, use default value on error.
+    
+    Mainly for empty ratios, double commas.
+    """
+    try:
+        return float(x)
+    except ValueError:
+        print("'{}' is not a number, converted to {}".format(x,vdef))
+        return vdef
+
+def split_l2(s, kr, kc, indsingles = False, fmap = fidentity, basestruct = None, indflip = False):
+    """Split string to 2d list (ie L2) per row and col keys.
+    
+    The output is a list of lists, each of varying length.
+    If a L2 basestruct is provided,
+    will adhere to its structure using the following broadcast rules:
+    - Basically matches row by row of base and new.
+    - If a new row is shorter than base, the last value is repeated to fill the row.
+    - If both are the same length, copied as is.
+    - If new row is longer, then additional values will overflow to the next row.
+      This might be unintended sometimes, but allows making all items col separated,
+      then the new structure is simply adapted to the base structure.
+    - If there are too many values in new, they will be ignored.
+    - If there are too few values in new, the last one is repeated to fill base. 
+    For mixed row + col ratios, singles flag is provided -
+    will extract the first value of each row to a separate list,
+    and output structure is (row L1,cell L2).
+    There MUST be at least one value for row, one value for col when singles is on;
+    to prevent errors, the row value is copied to col if it's alone (shouldn't affect results).
+    Singles still respects base broadcast rules, and repeats its own last value.
+    The fmap function is applied to each cell before insertion to L2;
+    if it fails, a default value is used.
+    If flipped, the keyword for columns is applied before rows.
+    TODO: Needs to be a case insensitive split. Use re.split.
+    """
+    if indflip:
+        tmp = kr
+        kr = kc
+        kc = tmp
+    lret = []
+    if basestruct is None:
+        lrows = s.split(kr)
+        lrows = [row.split(kc) for row in lrows]
+        for r in lrows:
+            cell = [fmap(x) for x in r]
+            lret.append(cell)
+        if indsingles:
+            lsingles = [row[0] for row in lret]
+            lcells = [row[1:] if len(row) > 1 else row for row in lret]
+            lret = (lsingles,lcells)
+    else:
+        lrows = s.split(kr)
+        r = 0
+        lcells = []
+        lsingles = []
+        vlast = 1
+        for row in lrows:
+            row2 = row.split(kc)
+            row2 = [fmap(x) for x in row2]
+            vlast = row2[-1]
+            indstop = False
+            while not indstop:
+                if (r >= len(basestruct) # Too many cell values, ignore.
+                or (len(row2) == 0 and len(basestruct) > 0)): # Cell exhausted.
+                    indstop = True
+                if not indstop:
+                    if indsingles: # Singles split.
+                        lsingles.append(row2[0]) # Row ratio.
+                        if len(row2) > 1:
+                            row2 = row2[1:]
+                    if len(basestruct[r]) >= len(row2): # Repeat last value.
+                        indstop = True
+                        broadrow = row2 + [row2[-1]] * (len(basestruct[r]) - len(row2))
+                        r = r + 1
+                        lcells.append(broadrow)
+                    else: # Overfilled this row, cut and move to next.
+                        broadrow = row2[:len(basestruct[r])]
+                        row2 = row2[len(basestruct[r]):]
+                        r = r + 1
+                        lcells.append(broadrow)
+        # If not enough new rows, repeat the last one for entire base, preserving structure.
+        cur = len(lcells)
+        while cur < len(basestruct):
+            lcells.append([vlast] * len(basestruct[cur]))
+            cur = cur + 1
+        lret = lcells
+        if indsingles:
+            lsingles = lsingles + [lsingles[-1]] * (len(basestruct) - len(lsingles))
+            lret = (lsingles,lcells)
+    return lret
+
+def is_l2(l):
+    return isinstance(l[0],list) 
+
+def l2_count(l):
+    cnt = 0
+    for row in l:
+        cnt + cnt + len(row)
+    return cnt
+
+def list_percentify(l):
+    """Convert each row in L2 to relative part of 100%. 
+    
+    Also works on L1, applying once globally.
+    """
+    lret = []
+    if is_l2(l):
+        for row in l:
+            # row2 = [float(v) for v in row]
+            row2 = [v / sum(row) for v in row]
+            lret.append(row2)
+    else:
+        row = l[:]
+        # row2 = [float(v) for v in row]
+        row2 = [v / sum(row) for v in row]
+        lret = row2
+    return lret
+
+def list_cumsum(l):
+    """Apply cumsum to L2 per row, ie newl[n] = l[0:n].sum .
+    
+    Works with L1.
+    Actually edits l inplace, idc.
+    """
+    lret = []
+    if is_l2(l):
+        for row in l:
+            for (i,v) in enumerate(row):
+                if i > 0:
+                    row[i] = v + row[i - 1]
+            lret.append(row)
+    else:
+        row = l[:]
+        for (i,v) in enumerate(row):
+            if i > 0:
+                row[i] = v + row[i - 1]
+        lret = row
+    return lret
+
+def list_rangify(l):
+    """Merge every 2 elems in L2 to a range, starting from 0.  
+    
+    """
+    lret = []
+    if is_l2(l):
+        for row in l:
+            row2 = [0] + row
+            row3 = []
+            for i in range(len(row2) - 1):
+                row3.append([row2[i],row2[i + 1]]) 
+            lret.append(row3)
+    else:
+        row2 = [0] + l
+        row3 = []
+        for i in range(len(row2) - 1):
+            row3.append([row2[i],row2[i + 1]]) 
+        lret = row3
+    return lret
+
+def round_dim(x,y):
+    """Return division of two numbers, rounding 0.5 up.
+    
+    Seems that dimensions which are exactly 0.5 are rounded up - see 680x488, second iter.
+    A simple mod check should get the job done.
+    If not, can always brute force the divisor with +-1 on each of h/w.
+    """
+    return x // y + (x % y >= y // 2)
+
+
+def isfloat(t):
+    try:
+        float(t)
+        return True
+    except Exception:
+        return False
+
+def ratiosdealer(aratios2,aratios2r):
+    aratios2 = list_percentify(aratios2)
+    aratios2 = list_cumsum(aratios2)
+    aratios2 = list_rangify(aratios2)
+    aratios2r = list_percentify(aratios2r)
+    aratios2r = list_cumsum(aratios2r)
+    aratios2r = list_rangify(aratios2r)
+    return aratios2,aratios2r
+
+def changecs(ratios):
+    ratios = ratios.replace(",","_")
+    ratios = ratios.replace(";",",")
+    ratios = ratios.replace("_",";")
+    return ratios
+
+def makeimgtmp(aratios,mode,usecom,usebase, flipper, inprocess = False):
+    if mode == "Columns":mode = "Horizontal"
+    if mode == "Rows":mode = "Vertical"
+
+    if flipper: aratios = changecs(aratios)
+
+    indflip = ("Ver" in mode)
+    if DELIMROW not in aratios: # Commas only - interpret as 1d.
+        aratios2 = split_l2(aratios, DELIMROW, DELIMCOL, fmap = ffloatd(1), indflip = False)
+        aratios2r = [1]
+    else:
+        (aratios2r,aratios2) = split_l2(aratios, DELIMROW, DELIMCOL, 
+                                        indsingles = True, fmap = ffloatd(1), indflip = indflip)
+    print(aratios2r,aratios2)
+    (aratios2,aratios2r) = ratiosdealer(aratios2,aratios2r)
+    
+    h = w = 128
+    fx = np.zeros((h,w, 3), np.uint8)
+    # Base image is coloured according to region divisions, roughly.
+    for (i,ocell) in enumerate(aratios2r):
+        for icell in aratios2[i]:
+            # SBM Creep: Colour by delta so that distinction is more reliable.
+            if not indflip:
+                fx[int(h*ocell[0]):int(h*ocell[1]),int(w*icell[0]):int(w*icell[1]),:] = fcolourise()
+            else:
+                fx[int(h*icell[0]):int(h*icell[1]),int(w*ocell[0]):int(w*ocell[1]),:] = fcolourise()
+    img = PIL.Image.fromarray(fx)
+    draw = PIL.ImageDraw.Draw(img)
+    c = 0
+    def coldealer(col):
+        if sum(col) > 380:return "black"
+        else:return "white"
+    # Add region counters at the top left corner, coloured according to hue.
+    for (i,ocell) in enumerate(aratios2r):
+        for icell in aratios2[i]: 
+            if not indflip:
+                draw.text((int(w*icell[0]),int(h*ocell[0])),f"{c}",coldealer(fx[int(h*ocell[0]),int(w*icell[0])]))
+            else: 
+                draw.text((int(w*ocell[0]),int(h*icell[0])),f"{c}",coldealer(fx[int(h*icell[0]),int(w*ocell[0])]))
+            c += 1
+    
+    # Create ROW+COL template from regions.
+    txtkey = fspace(DKEYINOUT[("in", indflip)]) + NLN  
+    lkeys = [txtkey.join([""] * len(cell)) for cell in aratios2]
+    txtkey = fspace(DKEYINOUT[("out", indflip)]) + NLN
+    template = txtkey.join(lkeys) 
+    if usebase:
+        template = fspace(KEYBASE) + NLN + template
+    if usecom:
+        template = fspace(KEYCOMM) + NLN + template
+
+    if inprocess:
+        changer = template.split(NLN)
+        changer = [l.strip() for l in changer]
+        return changer
+    
+    return img,gr.update(value = template)
+
+################################################################
+##### matrix
+fcountbrk = lambda x: x.count(KEYBRK)
+fint = lambda x: int(x)
+
+def matrixdealer(self, p, aratios, bratios, mode):
+    print(aratios, bratios, mode)
+    if "Ran" in mode:
+        randdealer(self,p,aratios,bratios)
+        return 
+    # The addrow/addcol syntax is better, cannot detect regular breaks without it.
+    # In any case, the preferred method will anchor the L2 structure. 
+    # No prompt formatting is performed. Used only for region calculations
+    prompt = p.prompt
+    if self.debug: print("in matrixdealer",prompt)
+    if KEYCOMM in prompt: prompt = prompt.split(KEYCOMM,1)[1]
+    if KEYBASE in prompt: prompt = prompt.split(KEYBASE,1)[1]
+
+    indflip = ("Ver" in mode)
+    if (KEYCOL in prompt.upper() or KEYROW in prompt.upper()):
+        breaks = prompt.count(KEYROW) + prompt.count(KEYCOL) + int(self.usebase)
+        # Prompt anchors, count breaks between special keywords.
+        lbreaks = split_l2(prompt, KEYROW, KEYCOL, fmap = fcountbrk, indflip = indflip)
+        if (DELIMROW not in aratios
+        and (KEYROW in prompt.upper()) != (KEYCOL in prompt.upper())):
+            # By popular demand, 1d integrated into 2d.
+            # This works by either adding a single row value (inner),
+            # or setting flip to the reverse (outer).
+            # Only applies when using just ADDROW / ADDCOL keys, and commas in ratio.
+            indflip2 = False
+            if (KEYROW in prompt.upper()) == indflip:
+                aratios = "1" + DELIMCOL + aratios
+            else:
+                indflip2 = True
+            (aratios2r,aratios2) = split_l2(aratios, DELIMROW, DELIMCOL, indsingles = True,
+                                fmap = ffloatd(1), basestruct = lbreaks,
+                                indflip = indflip2)
+        else: # Standard ratios, split to rows and cols.
+            (aratios2r,aratios2) = split_l2(aratios, DELIMROW, DELIMCOL, indsingles = True,
+                                            fmap = ffloatd(1), basestruct = lbreaks, indflip = indflip)
+        # More like "bweights", applied per cell only.
+        bratios2 = split_l2(bratios, DELIMROW, DELIMCOL, fmap = ffloatd(0), basestruct = lbreaks, indflip = indflip)
+    else:
+        breaks = prompt.count(KEYBRK) + int(self.usebase)
+        (aratios2r,aratios2) = split_l2(aratios, DELIMROW, DELIMCOL, indsingles = True, fmap = ffloatd(1), indflip = indflip)
+        # Cannot determine which breaks matter.
+        lbreaks = split_l2("0", KEYROW, KEYCOL, fmap = fint, basestruct = aratios2, indflip = indflip)
+        bratios2 = split_l2(bratios, DELIMROW, DELIMCOL, fmap = ffloatd(0), basestruct = lbreaks, indflip = indflip)
+        # If insufficient breaks, try to broadcast prompt - a bit dumb.
+        breaks = fcountbrk(prompt)
+        lastprompt = prompt.rsplit(KEYBRK)[-1]
+        if l2_count(aratios2) > breaks: 
+            prompt = prompt + (fspace(KEYBRK) + lastprompt) * (l2_count(aratios2) - breaks) 
+    (aratios,aratiosr) = ratiosdealer(aratios2,aratios2r)
+    bratios = bratios2 
+    
+    # Merge various L2s to cells and rows.
+    drows = []
+    for r,_ in enumerate(lbreaks):
+        dcells = []
+        for c,_ in enumerate(lbreaks[r]):
+            d = RegionCell(aratios[r][c][0], aratios[r][c][1], bratios[r][c], lbreaks[r][c])
+            dcells.append(d)
+        drow = RegionRow(aratiosr[r][0], aratiosr[r][1], dcells)
+        drows.append(drow)
+
+    self.aratios = drows
+    self.bratios = bratios
+
+################################################################
+##### inpaint
+
+"""
+SBM mod: Mask polygon region.
+- Basically a version of inpainting, where polygon outlines are drawn and added to a coloured image.
+- Colours from the image are picked apart for masks corresponding to regions.
+- In new mask mode, masks are stored instead of aratios, and applied to each region forward.
+- Mask can be uploaded (alpha, no save), and standard colours are detected from it.
+- Uncoloured regions default to the first colour detected;
+  however, if base mode is used, instead base will be applied to the remainder at 100% strength.
+  I think this makes it far more useful. At 0 strength, it will apply ONLY to said regions.
+- V2: Corrects and detects colours from upload.
+- Mask mode presets save mask to a file, which is loaded with the preset.
+- Added -1 colour to clear sections, an eraser.
+"""
+
+POLYFACTOR = 1.5 # Small lines are detected as shapes.
+COLREG = None # Computed colour regions cache. Array. Extended whenever a new colour is requested.
+REGUSE = dict() # Used regions. Reset on new canvas / upload (preset). 
+IDIM = 512
+CBLACK = 255
+MAXCOLREG = 360 - 1 # Hsv goes by degrees.
+VARIANT = 0 # Ensures that the sketch canvas is actually refreshed.
+# Permitted hsv error range for mask upload (due to compression).
+# Mind, wrong hue might throw off the mask entirely and is not corrected.
+# HSV_RANGE = (125,130)
+# HSV_VAL = 128
+HSV_RANGE = (0.49,0.51)
+HSV_VAL = 0.5
+CCHANNELS = 3
+COLWHITE = (255,255,255)
+# Optional replacement mode of nonstandard colours from the mask during upload with white.
+# Pros: Clear and obvious display of regions.
+# Cons: Cannot use the image as a background for tracing (eg openpose or depthmap).
+# Compromise: Do not replace, but show the used regions.
+INDCOLREPL = False
+
+def get_colours(img):
+    """List colours used in image (as nxc array).
+    
+    """
+    return np.unique(img.reshape(-1, img.shape[-1]), axis=0)
+
+def generate_unique_colours(n):
+    """Generate n visually distinct colors as a list of RGB tuples.
+    
+    Uses the hue of hsv, with balanced saturation & value.
+    """
+    hsv_colors = [(x*1.0/n, 0.5, 0.5) for x in range(n)]
+    rgb_colors = [tuple(int(i * CBLACK) for i in colorsys.hsv_to_rgb(*hsv)) for hsv in hsv_colors]
+    return rgb_colors
+
+def deterministic_colours(n, lcol = None):
+    """Generate n visually distinct & consistent colours as a list of RGB tuples.
+    
+    Uses the hue of hsv, with balanced saturation & value.
+    Goes around the cyclical 0-256 and picks each /2 value for every round.
+    Continuation rules: If pcyv != ccyv in next round, then we don't care.
+    If pcyv == ccyv, we want to get the cval + delta of last elem.
+    If lcol > n, will return it as is.
+    """
+    if n <= 0:
+        return None
+    pcyc = -1
+    cval = 0
+    if lcol is None:
+        st = 0
+    elif n <= len(lcol):
+        # return lcol[:n] # Truncating the list is accurate, but pointless.
+        return lcol
+    else:
+        st = len(lcol)
+        if st > 0:
+            pcyc = np.ceil(np.log2(st))
+            # This is erroneous on st=2^n, but we don't care.
+            dlt = 1 / (2 ** pcyc)
+            cval = dlt + 2 * dlt * (st % (2 ** (pcyc - 1)) - 1)
+
+    lhsv = []
+    for i in range(st,n):
+        ccyc = np.ceil(np.log2(i + 1))
+        if ccyc == 0: # First col = 0.
+            cval = 0
+            pcyc = ccyc
+        elif pcyc != ccyc: # New cycle, start from the half point between 0 and first point.
+            dlt = 1 / (2 ** ccyc)
+            cval = dlt
+            pcyc = ccyc
+        else:
+            cval = cval + 2 * dlt # Jumps over existing vals.
+        lhsv.append(cval)
+    lhsv = [(v, 0.5, 0.5) for v in lhsv] # Hsv conversion only works 0:1.
+    lrgb = [colorsys.hsv_to_rgb(*hsv) for hsv in lhsv]
+    lrgb = (np.array(lrgb) * (CBLACK + 1)).astype(np.uint8) # Convert to colour uints.
+    lrgb = lrgb.reshape(-1, CCHANNELS)
+    if lcol is not None:
+        lrgb = np.concatenate([lcol, lrgb])
+    return lrgb
+
+def index_rows(mat):
+    """In 2D matrix, add column containing row number.
+    
+    Pandas stuff, can't find a clever way to find first row in np.
+    """
+    return np.concatenate([np.arange(len(mat)).reshape(-1,1),mat],axis = 1)
+
+def detect_image_colours(img, inddict = False):
+    """Detect relevant hsv colours in image and clean up the standard mask.
+    
+    Basically, converts colours to hsv, checks which ones are within range,
+    converts them to the exact sv value we need, deletes irrelevant colours,
+    and creates a list of used colours via a form of np first row lookup.
+    Problem: Rgb->hsb and back is not lossless in np / cv. Getting 128->127.
+    Looks like the only option is to use colorsys which is contiguous.
+    To maximise efficiency, I've applied it to the unique colours instead of entire image,
+    and then each colour is mapped via np masking (propagation),
+    by adding a third fake dim for each of colours, flattened image.
+    It might be possible to use cv2 one way for the filter, but I think that's risky,
+    and likely doesn't save much processing (heaviest op is get_colours for large image).
+    Creep: Apply erosion so thin regions are ignored. This would need be applied on processing as well.
+    """
+    global REGUSE
+    global COLREG
+    global VARIANT
+    if img is None: # Do nothing if no image passed. 
+        return None, None
+    VARIANT = 0 # Upload doesn't need variance, it refreshes automatically.
+    (h,w,c) = img.shape
+    # Get unique colours, create rgb-hsv mapping and filtering.
+    # hsv_img = cv2.cvtColor(img, cv2.COLOR_RGB2HSV)
+    # skimg = cv2.cvtColor(hsv_img, cv2.COLOR_HSV2RGB)
+    lrgb = get_colours(img)
+    lhsv = np.apply_along_axis(lambda x: colorsys.rgb_to_hsv(*x), axis=-1, arr = lrgb / CBLACK)
+    msk = ((lhsv[:,1] >= HSV_RANGE[0]) & (lhsv[:,1] <= HSV_RANGE[1]) &
+           (lhsv[:,2] >= HSV_RANGE[0]) & (lhsv[:,2] <= HSV_RANGE[1]))
+    lfltrgb = lrgb[msk]
+    lflthsv = lhsv[msk]
+    lflthsv[:,1:] = HSV_VAL
+    if len(lfltrgb) > 0:
+        lfltfix = np.apply_along_axis(lambda x: colorsys.hsv_to_rgb(*x), axis=-1, arr=lflthsv)
+        lfltfix = (lfltfix * (CBLACK + 1)).astype(np.uint8)
+    else: # No relevant colours.
+        lfltfix = lfltrgb
+    # Mask update each colour in the image.
+    # I tried to use isin, but it seems to detect any permutation.
+    # It's better to roll colour channel to the front, add extra fake dims,
+    # then use direct comparison, relying on np broadcasting.
+    # Shape: colour x search x img
+    cnt = len(lfltrgb)
+    img2 = img.reshape(-1,c,1)
+    img2 = np.moveaxis(img2,0,-1)
+    lfltrgb2 = np.moveaxis(lfltrgb,-1,0)
+    lfltrgb2 = lfltrgb2.reshape(c,-1,1)
+    msk2 = (img2 == lfltrgb2).all(axis = 0).reshape(cnt,h,w)
+    for i,_ in enumerate(lfltrgb):
+        img[msk2[i]] = lfltfix[i]
+    # Empty all nonfiltered regions.
+    msk3 = ~(msk2.any(axis = 0))
+    if INDCOLREPL: # Don't remove nonstandard.
+        img[msk3] = COLWHITE
+    # Gen all colours, match with the fixed filtered list.
+    # I can think of no mathematical function to inverse the colour gen function.
+    # Also, imperfect hash, so ~60 colours go over the edge. Should have 100% matches at x2. 
+    COLREG = deterministic_colours(2 * MAXCOLREG, COLREG)
+    cow = index_rows(COLREG)
+    regrows = [cow[(COLREG == f).all(axis = 1)] for f in lfltfix]
+    # MAX_KEY_VALUE provides a threshold value. Only those colors are added to REGUSE, for which the key values 
+    # (i.e., the indices of the colors in the 'regrows' array) are less than this threshold.
+    # Colors with indices greater than MAX_KEY_VALUE are considered "similar colors" and are not treated as separate masks. 
+    unique_keys = set(reg[0,0] for reg in regrows if len(reg) > 0)
+    # The purpose of this is to reduce the number of colors being processed, particularly for colors that are 
+    # close to each other, which may be slightly different due to noise in the image or minor differences in color encoding.
+    # By setting an appropriate MAX_KEY_VALUE, these minor color differences can be effectively filtered out, 
+    # thereby reducing the number of colors being processed and making color processing more accurate and efficient.
+    MAX_KEY_VALUE = len(unique_keys) + 20
+    REGUSE = {reg[0,0]: reg[0,1:].tolist() for reg in regrows if len(reg) > 0 and reg[0,0] <= MAX_KEY_VALUE}
+    # REGUSE.discard(COLWHITE)
+    
+    # Must set to dict due to gradio preprocess assertion, in preset load.
+    # CONT: This doesn't work. Postprocess expects image. Maybe use dict for preset, not upload.
+    if inddict:
+        img = {"image":img, "mask":None}
+    
+    return img, None # Clears the upload area. A bit cleaner.
+
+def save_mask(img, flpath):
+    """Save mask to file.
+    
+    These will be loaded as part of a preset.
+    Cv's colour scheme is an annoyance, but avoiding yet another import. 
+    """
+    # Cv's colour scheme is annoying.
+    try:
+        img = img["image"]
+    except Exception:
+        pass
+    if VARIANT != 0: # Always save without variance.
+        img = img[:-VARIANT,:-VARIANT,:]
+    img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+    cv2.imwrite(flpath, img)
+
+def load_mask(flpath):
+    """Load mask from file.
+    
+    Does not edit mask automatically (detect colours).
+    """
+    try:
+        img = cv2.imread(flpath)
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    except Exception: # Could not load mask.
+        img = None
+    return img
+
+def detect_polygons(img,num):
+    """Convert stroke + region to standard coloured mask.
+    
+    Negative colours will clear the mask instead, and not ++.
+    """
+    global COLREG
+    global VARIANT
+    global REGUSE
+
+    # I dunno why, but mask has a 4th colour channel, which contains nothing. Alpha?
+    if VARIANT != 0:
+        out = img["image"][:-VARIANT,:-VARIANT,:CCHANNELS]
+        img = img["mask"][:-VARIANT,:-VARIANT,:CCHANNELS]
+    else:
+        out = img["image"][:,:,:CCHANNELS]
+        img = img["mask"][:,:,:CCHANNELS]
+
+    # Convert the binary image to grayscale
+    if img is None:
+        img = np.zeros([IDIM,IDIM,CCHANNELS],dtype = np.uint8) + CBLACK # Stupid cv.
+    if out is None:
+        out = np.zeros_like(img) + CBLACK # Stupid cv.
+    bimg = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
+
+    # Find contours in the image
+    # Must reverse colours, otherwise draws an outer box (0->255). Dunno why gradio uses 255 for white anyway. 
+    contours, hierarchy = cv2.findContours(bimg, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+
+    #img2 = np.zeros_like(img) + 255 # Fresh image.
+    img2 = out # Update current image.
+
+    if num < 0:
+        color = COLWHITE
+    else:
+        COLREG = deterministic_colours(int(num) + 1, COLREG)
+        color = COLREG[int(num),:]
+        REGUSE[num] = color.tolist()
+    # Loop through each contour and detect polygons
+    for cnt in contours:
+        # Approximate the contour to a polygon
+        approx = cv2.approxPolyDP(cnt, 0.0001 * cv2.arcLength(cnt, True), True)
+
+        # If the polygon has 3 or more sides and is fully enclosed, fill it with a random color
+        # if len(approx) >= 3: # BAD test.
+        if cv2.contourArea(cnt) > cv2.arcLength(cnt, True) * POLYFACTOR: # Better, still messes up on large brush.
+            #SBM BUGGY, prevents contours from . cv2.pointPolygonTest(approx, (approx[0][0][0], approx[0][0][1]), False) >= 0:
+            
+            # Draw the polygon on the image with a new random color
+            color = [int(v) for v in color] # Opencv is dumb / C based and can't handle an int64 array.
+            #cv2.drawContours(img2, [approx], 0, color = color) # Only outer sketch.
+            cv2.fillPoly(img2,[approx],color = color)
+
+    # Convert the grayscale image back to RGB
+    #img2 = cv2.cvtColor(img2, cv2.COLOR_GRAY2RGB) # Converting to grayscale is dumb.
+
+    skimg = create_canvas(img2.shape[0], img2.shape[1], indwipe = False)
+    if VARIANT != 0:
+        skimg[:-VARIANT,:-VARIANT,:] = img2
+    else:
+        skimg[:,:,:] = img2
+    print("Region sketch size", skimg.shape)    
+    return skimg, num + 1 if (num >= 0 and num + 1 <= CBLACK) else num
+
+def detect_mask(img, num, mult = CBLACK):
+    """Extract specific colour and return mask.
+    
+    Multiplier for correct display.
+    Also tags colour in case someone uses the upload interface. 
+    """
+    global REGUSE
+    try:
+        img = img["image"]
+    except Exception:
+        pass
+    if img is None:
+        return None
+    indnot = False
+    if num < 0: # Detect unmasked region.
+        if INDCOLREPL: # In replacement mode, all colours are either region or white.
+            color = np.array(COLWHITE).reshape([1,1,CCHANNELS])
+        else: # In nonrepl mode, mask all the regions and invert.
+            color = np.array(list(REGUSE.values())) # nx3
+            color = np.moveaxis(color,-1,0) # 3xn
+            color = color.reshape(1,1,*color.shape) # 1x1x3xn
+            img = img.reshape(*img.shape,1) # Same.
+            indnot = True
+    else:
+        color = deterministic_colours(int(num) + 1)[-1]
+        color = color.reshape([1,1,CCHANNELS])
+    if indnot: # Negation of a list of regions.
+        mask = (~(img == color)).all(-1).all(-1)
+        mask = mask * mult
+    else:
+        mask = ((img == color).all(-1)) * mult
+    if mask.sum() > 0 and num >= 0:
+        REGUSE[num] = color.reshape(-1).tolist()
+    return mask
+
+def draw_region(img, num):
+    """Simply runs polygon detection, followed by mask on result.
+    
+    Saves extra inconvenient button. Since num is auto incremented, we take the old val.
+    """
+    img, num2 = detect_polygons(img, num)
+    mask = detect_mask(img, num)
+    # Gradio is stupid, I have to force feed it a dict so preprocess doesn't break.
+    # Disabled here, can only be fixed reliably in preprocess.
+    # dimg = {"image":img, "mask": None}
+    dimg = img
+    return dimg, num2, mask
+
+def draw_image(img, inddict = False):
+    """Runs colour detection followed by mask on -1 to show which colours are regions.
+    
+    """
+    img, clearer = detect_image_colours(img,inddict)
+    mask = detect_mask(img, -1)
+    dimg = img
+    return dimg, clearer, mask
+
+def create_canvas(h, w, indwipe = True):
+    """New region sketch area.
+    
+    Small variant value is added (and ignored later) due to gradio refresh bug.
+    Meant to be used only to start over or when the image dims change.
+    """
+    global VARIANT
+    global REGUSE
+    VARIANT = 1 - VARIANT
+    if indwipe:
+        REGUSE = dict()
+    vret =  np.zeros(shape = (h + VARIANT, w + VARIANT, CCHANNELS), dtype = np.uint8) + CBLACK
+    return vret
+
+# SBM In mask mode, grabs each mask from coloured mask image.
+# If there's no base, remainder goes to first mask.
+# If there's a base, it will receive its own remainder mask, applied at 100%.
+def inpaintmaskdealer(self, p, bratios, usebase, polymask):
+    prompt = p.prompt
+    if self.debug: print("in inpaintmaskdealer",prompt)
+    if KEYCOMM in prompt: prompt = prompt.split(KEYCOMM,1)[1]
+    if KEYBASE in prompt: prompt = prompt.split(KEYBASE,1)[1]
+    # Prep masks.
+    self.regmasks = []
+    tm = None
+    # Sort colour dict by key, return value for masking.
+    #for _,c in sorted(REGUSE.items(), key = lambda x: x[0]):
+    for c in sorted(REGUSE.keys()):
+        m = detect_mask(polymask, c, 1)
+        if VARIANT != 0:
+            m = m[:-VARIANT,:-VARIANT]
+        if m.any():
+            if tm is None:
+                tm = np.zeros_like(m) # First mask is ignored deliberately.
+                if self.usebase: # In base mode, base gets the outer regions.
+                    tm = tm + m
+            else:
+                tm = tm + m
+            m = m.reshape([1, *m.shape]).astype(np.float16)
+            t = torch.from_numpy(m).to(devices.device) 
+            self.regmasks.append(t)
+    # First mask applies to all unmasked regions.
+    m = 1 - tm
+    m = m.reshape([1, *m.shape]).astype(np.float16)
+    t = torch.from_numpy(m).to(devices.device)
+    if self.usebase:
+        self.regbase = t
+    else:
+        self.regbase = None
+        self.regmasks[0] = t
+    
+    # Simulated region anchroing for base weights.
+    breaks = prompt.count(KEYBRK)
+    self.bratios = split_l2(bratios, DELIMROW, DELIMCOL, fmap = ffloatd(0),
+                            basestruct = [[0] * (breaks + 1)], indflip = False)
+
+def randdealer(self,p,aratios,bratios):
+    # h*w の大きさのテンソルを作成
+    tensor = torch.zeros((p.height//8, p.width//8)).to("cuda")
+    x,y = int(aratios.split(",")[0]),int(aratios.split(",")[1])
+
+
+
+    # 領域ごとのサイズを計算
+    dh, dw = p.height//8 // x, p.width//8 // y
+    lbreaks = p.prompt.count(KEYBRK) + 1
+
+    bratios = bratios.split(",") if self.usebase else [0]
+    bratios = [float(b) for b in bratios]
+    while len(bratios) <= lbreaks:
+        bratios.append(bratios[0])
+
+    # 領域ごとに0から3までのランダムな値を設定
+    for i in range(x):
+        for j in range(y):
+            random_value = torch.randint(0, lbreaks, (1,))
+            tensor[i*dh:(i+1)*dh, j*dw:(j+1)*dw] = random_value
+    tensors = []
+
+    ranbase = torch.ones_like(tensor)
+
+    for i in range(lbreaks):
+        add = torch.where(tensor==i, 1*(1-bratios[i]),0)
+        tensors.append(add)
+        ranbase = ranbase - add
+
+    drows = []
+    dcells = []
+    for c in range(lbreaks):
+        d = RegionCell(0,0 , 0, 0)
+        dcells.append(d)
+    drow = RegionRow(0, 1, dcells)
+    drows.append(drow)
+
+    self.aratios = drows
+    self.ransors = tensors
+    self.ranbase = ranbase

regional-prompter-main/scripts/rp.py

@@ -0,0 +1,1051 @@
+import os.path
+from importlib import reload
+import launch
+from pprint import pprint
+import gradio as gr
+import numpy as np
+from PIL import Image
+import modules.ui
+import modules # SBM Apparently, basedir only works when accessed directly.
+from modules import paths, scripts, shared, extra_networks
+from modules.processing import Processed
+from modules.script_callbacks import (on_ui_settings,
+                                      CFGDenoisedParams, CFGDenoiserParams, on_cfg_denoised, on_cfg_denoiser)
+import scripts.attention
+import scripts.latent
+import scripts.regions
+try:
+    reload(scripts.regions) # update without restarting web-ui.bat
+    reload(scripts.attention)
+    reload(scripts.latent)
+except:
+    pass
+import json  # Presets.
+from json.decoder import JSONDecodeError
+from scripts.attention import (TOKENS, hook_forwards, reset_pmasks, savepmasks)
+from scripts.latent import (denoised_callback_s, denoiser_callback_s, lora_namer,
+                            restoremodel, setloradevice, setuploras, unloadlorafowards)
+from scripts.regions import (MAXCOLREG, IDIM, KEYBRK, KEYBASE, KEYCOMM, KEYPROMPT, ALLKEYS, ALLALLKEYS,
+                             create_canvas, draw_region, #detect_mask, detect_polygons,  
+                             draw_image, save_mask, load_mask, changecs,
+                             floatdef, inpaintmaskdealer, makeimgtmp, matrixdealer)
+
+FLJSON = "regional_prompter_presets.json"
+# Modules.basedir points to extension's dir. script_path or scripts.basedir points to root.
+PTPRESET = modules.scripts.basedir()
+PTPRESETALT = os.path.join(paths.script_path, "scripts")
+
+def lange(l):
+    return range(len(l))
+
+orig_batch_cond_uncond = shared.opts.batch_cond_uncond if hasattr(shared.opts,"batch_cond_uncond") else shared.batch_cond_uncond
+
+PRESETSDEF =[
+    ["Vertical-3", "Vertical",'1,1,1',"",False,False,False,"Attention",False,"0","0"],
+    ["Horizontal-3", "Horizontal",'1,1,1',"",False,False,False,"Attention",False,"0","0"],
+    ["Horizontal-7", "Horizontal",'1,1,1,1,1,1,1',"0.2",True,False,False,"Attention",False,"0","0"],
+    ["Twod-2-1", "Horizontal",'1,2,3;1,1',"0.2",False,False,False,"Attention",False,"0","0"],
+]
+
+ATTNSCALE = 8 # Initial image compression in attention layers.
+
+fhurl = lambda url, label: r"""<a href="{}">{}</a>""".format(url, label)
+GUIDEURL = r"https://github.com/hako-mikan/sd-webui-regional-prompter"
+MATRIXURL = GUIDEURL + r"#2d-region-assignment"
+MASKURL = GUIDEURL + r"#mask-regions-aka-inpaint-experimental-function"
+PROMPTURL = GUIDEURL + r"/blob/main/prompt_en.md"
+PROMPTURL2 = GUIDEURL + r"/blob/main/prompt_ja.md"
+
+
+def ui_tab(mode, submode):
+    """Structures components for mode tab.
+    
+    Semi harcoded but it's clearer this way.
+    """
+    vret = None
+    if mode == "Matrix":
+        with gr.Row():
+            mguide = gr.HTML(value = fhurl(MATRIXURL, "Matrix mode guide")) 
+        with gr.Row():
+            mmode = gr.Radio(label="Main Splitting", choices=submode, value="Columns", type="value", interactive=True)
+            ratios = gr.Textbox(label="Divide Ratio",lines=1,value="1,1",interactive=True,elem_id="RP_divide_ratio",visible=True)
+        with gr.Row():
+            with gr.Column():
+                maketemp = gr.Button(value="visualize and make template")
+                template = gr.Textbox(label="template",interactive=True,visible=True)
+                flipper = gr.Checkbox(label = 'flip "," and ";"', value = False)
+            with gr.Column():
+                areasimg = gr.Image(type="pil", show_label  = False, height=256, width=256)
+        # Need to add maketemp function based on base / common checks.
+        vret = [mmode, ratios, maketemp, template, areasimg, flipper]
+    elif mode == "Mask":
+        with gr.Row():
+            xguide = gr.HTML(value = fhurl(MASKURL, "Inpaint+ mode guide"))
+        with gr.Row(): # Creep: Placeholder, should probably make this invisible.
+            xmode = gr.Radio(label="Mask mode", choices=submode, value="Mask", type="value", interactive=True)
+        with gr.Row(): # CREEP: Css magic to make the canvas bigger? I think it's in style.css: #img2maskimg -> height.
+            polymask = gr.Image(label = "Do not upload here until bugfix",elem_id="polymask",
+                                source = "upload", mirror_webcam = False, type = "numpy", tool = "sketch")#.style(height=480)
+        with gr.Row():
+            with gr.Column():
+                num = gr.Slider(label="Region", minimum=-1, maximum=MAXCOLREG, step=1, value=1)
+                canvas_width = gr.Slider(label="Inpaint+ Width", minimum=64, maximum=2048, value=512, step=8)
+                canvas_height = gr.Slider(label="Inpaint+ Height", minimum=64, maximum=2048, value=512, step=8)
+                btn = gr.Button(value = "Draw region + show mask")
+                # btn2 = gr.Button(value = "Display mask") # Not needed.
+                cbtn = gr.Button(value="Create mask area")
+            with gr.Column():
+                showmask = gr.Image(label = "Mask", shape=(IDIM, IDIM))
+                # CONT: Awaiting fix for https://github.com/gradio-app/gradio/issues/4088.
+                uploadmask = gr.Image(label="Upload mask here cus gradio",source = "upload", type = "numpy")
+        # btn.click(detect_polygons, inputs = [polymask,num], outputs = [polymask,num])
+        btn.click(draw_region, inputs = [polymask, num], outputs = [polymask, num, showmask])
+        # btn2.click(detect_mask, inputs = [polymask,num], outputs = [showmask])
+        cbtn.click(fn=create_canvas, inputs=[canvas_height, canvas_width], outputs=[polymask])
+        uploadmask.upload(fn = draw_image, inputs = [uploadmask], outputs = [polymask, uploadmask, showmask])
+        
+        vret = [xmode, polymask, num, canvas_width, canvas_height, btn, cbtn, showmask, uploadmask]
+    elif mode == "Prompt":
+        with gr.Row():
+            pguide = gr.HTML(value = fhurl(PROMPTURL, "Prompt mode guide"))
+            pguide2 = gr.HTML(value = fhurl(PROMPTURL2, "Extended prompt guide (jp)"))
+        with gr.Row():
+            pmode = gr.Radio(label="Prompt mode", choices=submode, value="Prompt", type="value", interactive=True)
+            threshold = gr.Textbox(label = "threshold", value = 0.4, interactive=True)
+        
+        vret = [pmode, threshold]
+
+    return vret
+            
+# modes, submodes. Order must be maintained so dict is inadequate. Must have submode for component consistency.
+RPMODES = [
+("Matrix", ("Columns","Rows","Random")),
+("Mask", ("Mask",)),
+("Prompt", ("Prompt", "Prompt-Ex")),
+]
+fgrprop = lambda x: {"label": x, "id": "t" + x, "elem_id": "RP_" + x}
+
+def mode2tabs(mode):
+    """Converts mode (in preset) to gradio tab + submodes.
+    
+    I dunno if it's possible to nest components or make them optional (probably not),
+    so this is the best we can do.
+    """
+    vret = ["Nope"] + [None] * len(RPMODES)
+    for (i,(k,v)) in enumerate(RPMODES):
+        if mode in v:
+            vret[0] = k
+            vret[i + 1] = mode
+    return vret
+    
+def tabs2mode(tab, *submode):
+    """Converts ui tab + submode list to a single value mode.
+    
+    Picks current submode based on tab, nothing clever. Submodes must be unique.
+    """
+    for (i,(k,_)) in enumerate(RPMODES):
+        if tab == k:
+            return submode[i]
+    return "Nope"
+    
+def expand_components(l):
+    """Converts json preset to component format.
+    
+    Assumes mode is the first value in list.
+    """
+    l = list(l) # Tuples cannot be altered.
+    tabs = mode2tabs(l[0])
+    return tabs + l[1:]
+
+def compress_components(l):
+    """Converts component values to preset format.
+    
+    Assumes tab + submodes are the first values in list.
+    """
+    l = list(l)
+    mode = tabs2mode(*l[:len(RPMODES) + 1])
+    return [mode] + l[len(RPMODES) + 1:]
+    
+class Script(modules.scripts.Script):
+    def __init__(self,active = False,mode = "Matrix",calc = "Attention",h = 0, w =0, debug = False, usebase = False, usecom = False, usencom = False, batch = 1,isxl = False, lstop=0, lstop_hr=0):
+        self.active = active
+        if mode == "Columns": mode = "Horizontal"
+        if mode == "Rows": mode = "Vertical"
+        self.mode = mode
+        self.calc = calc
+        self.h = h
+        self.w = w
+        self.debug = debug
+        self.usebase = usebase
+        self.usecom = usecom
+        self.usencom = usencom
+        self.batch_size = batch
+        self.isxl = isxl
+
+        self.aratios = []
+        self.bratios = []
+        self.divide = 0
+        self.count = 0
+        self.eq = True
+        self.pn = True
+        self.hr = False
+        self.hr_scale = 0
+        self.hr_w = 0
+        self.hr_h = 0
+        self.in_hr = False
+        self.xsize = 0
+        self.imgcount = 0
+        # for latent mode
+        self.filters = []
+        self.lora_applied = False
+        self.lstop = int(lstop)
+        self.lstop_hr = int(lstop_hr)
+        # for inpaintmask
+        self.regmasks = None
+        self.regbase = None
+        #for prompt region
+        self.pe = []
+        self.step = 0
+        
+        #script communicator
+        self.hooked = False
+        self.condi = 0
+
+        self.log = {}
+
+
+    def title(self):
+        return "Regional Prompter"
+
+    def show(self, is_img2img):
+        return modules.scripts.AlwaysVisible
+
+    infotext_fields = None
+    paste_field_names = []
+
+    def ui(self, is_img2img):
+        filepath = os.path.join(PTPRESET, FLJSON)
+
+        presets = []
+
+        presets = loadpresets(filepath)
+        presets = LPRESET.update(presets)
+
+        with gr.Accordion("Regional Prompter", open=False, elem_id="RP_main"):
+            with gr.Row():
+                active = gr.Checkbox(value=False, label="Active",interactive=True,elem_id="RP_active")
+                urlguide = gr.HTML(value = fhurl(GUIDEURL, "Usage guide"))
+            with gr.Row():
+                # mode = gr.Radio(label="Divide mode", choices=["Horizontal", "Vertical","Mask","Prompt","Prompt-Ex"], value="Horizontal",  type="value", interactive=True)
+                calcmode = gr.Radio(label="Generation mode", choices=["Attention", "Latent"], value="Attention",  type="value", interactive=True)
+            with gr.Row(visible=True):
+                # ratios = gr.Textbox(label="Divide Ratio",lines=1,value="1,1",interactive=True,elem_id="RP_divide_ratio",visible=True)
+                baseratios = gr.Textbox(label="Base Ratio", lines=1,value="0.2",interactive=True,  elem_id="RP_base_ratio", visible=True)
+            with gr.Row():
+                usebase = gr.Checkbox(value=False, label="Use base prompt",interactive=True, elem_id="RP_usebase")
+                usecom = gr.Checkbox(value=False, label="Use common prompt",interactive=True,elem_id="RP_usecommon")
+                usencom = gr.Checkbox(value=False, label="Use common negative prompt",interactive=True,elem_id="RP_usecommon")
+            
+            # Tabbed modes.
+            with gr.Tabs(elem_id="RP_mode") as tabs:
+                rp_selected_tab = gr.State("Matrix") # State component to document current tab for gen.
+                # ltabs = []
+                ltabp = []
+                for (i, (md,smd)) in enumerate(RPMODES):
+                    with gr.TabItem(**fgrprop(md)) as tab: # Tabs with a formatted id.
+                        # ltabs.append(tab)
+                        ltabp.append(ui_tab(md, smd))
+                    # Tab switch tags state component.
+                    tab.select(fn = lambda tabnum = i: RPMODES[tabnum][0], inputs=[], outputs=[rp_selected_tab])
+
+            # Hardcode expansion back to components for any specific events.
+            (mmode, ratios, maketemp, template, areasimg, flipper) = ltabp[0]
+            (xmode, polymask, num, canvas_width, canvas_height, btn, cbtn, showmask, uploadmask) = ltabp[1]
+            (pmode, threshold) = ltabp[2]
+            
+            with gr.Accordion("Presets",open = False):
+                with gr.Row():
+                    availablepresets = gr.Dropdown(label="Presets", choices=presets, type="index")
+                    applypresets = gr.Button(value="Apply Presets",variant='primary',elem_id="RP_applysetting")
+                with gr.Row():
+                    presetname = gr.Textbox(label="Preset Name",lines=1,value="",interactive=True,elem_id="RP_preset_name",visible=True)
+                    savesets = gr.Button(value="Save to Presets",variant='primary',elem_id="RP_savesetting")
+            with gr.Row():
+                lstop = gr.Textbox(label="LoRA stop step",value="0",interactive=True,elem_id="RP_ne_tenc_ratio",visible=True)
+                lstop_hr = gr.Textbox(label="LoRA Hires stop step",value="0",interactive=True,elem_id="RP_ne_unet_ratio",visible=True)
+                lnter = gr.Textbox(label="LoRA in negative textencoder",value="0",interactive=True,elem_id="RP_ne_tenc_ratio",visible=True)
+                lnur = gr.Textbox(label="LoRA in negative U-net",value="0",interactive=True,elem_id="RP_ne_unet_ratio",visible=True)
+            with gr.Row():
+                nchangeand = gr.Checkbox(value=False, label="disable convert 'AND' to 'BREAK'", interactive=True, elem_id="RP_ncand")
+                debug = gr.Checkbox(value=False, label="debug", interactive=True, elem_id="RP_debug")
+            mode = gr.Textbox(value = "Matrix",visible = False)
+
+            def changetabs(mode):
+                modes = ["Matrix", "Mask", "Prompt"]
+                if mode not in modes: mode = "Maxtix"
+                return gr.Tabs.update(selected="t"+mode)
+
+            mode.change(fn = changetabs,inputs=[mode],outputs=[tabs])
+            settings = [rp_selected_tab, mmode, xmode, pmode, ratios, baseratios, usebase, usecom, usencom, calcmode, nchangeand, lnter, lnur, threshold, polymask, lstop, lstop_hr, flipper]
+        
+        self.infotext_fields = [
+                (active, "RP Active"),
+                # (mode, "RP Divide mode"),
+                (mode, "RP Divide mode"),
+                (mmode, "RP Matrix submode"),
+                (xmode, "RP Mask submode"),
+                (pmode, "RP Prompt submode"),
+                (calcmode, "RP Calc Mode"),
+                (ratios, "RP Ratios"),
+                (baseratios, "RP Base Ratios"),
+                (usebase, "RP Use Base"),
+                (usecom, "RP Use Common"),
+                (usencom, "RP Use Ncommon"),
+                (nchangeand,"RP Change AND"),
+                (lnter,"RP LoRA Neg Te Ratios"),
+                (lnur,"RP LoRA Neg U Ratios"),
+                (threshold,"RP threshold"),
+                (lstop,"RP LoRA Stop Step"),
+                (lstop_hr,"RP LoRA Hires Stop Step"),
+                (flipper, "RP Flip")
+        ]
+
+        for _,name in self.infotext_fields:
+            self.paste_field_names.append(name)
+
+        def setpreset(select, *settings):
+            """Load preset from list.
+            
+            SBM: The only way I know how to get the old values in gradio,
+            is to pass them all as input.
+            Tab mode converts ui to single value.
+            """
+            # Need to swap all masked images to the source,
+            # getting "valueerror: cannot process this value as image".
+            # Gradio bug in components.postprocess, most likely.
+            settings = [s["image"] if (isinstance(s,dict) and "image" in s) else s for s in settings]
+            presets = loadpresets(filepath)
+            preset = presets[select]
+            preset = loadblob(preset)
+            preset = [fmt(preset.get(k, vdef)) for (k,fmt,vdef) in PRESET_KEYS]
+            preset = preset[1:] # Remove name.
+            preset = expand_components(preset)
+            # Change nulls to original value.
+            preset = [settings[i] if p is None else p for (i,p) in enumerate(preset)]
+            while  len(settings) >= len(preset):
+                    preset.append(0)
+            # return [gr.update(value = pr) for pr in preset] # SBM Why update? Shouldn't regular return do the job? 
+            return preset
+
+        maketemp.click(fn=makeimgtmp, inputs =[ratios,mmode,usecom,usebase,flipper],outputs = [areasimg,template])
+        applypresets.click(fn=setpreset, inputs = [availablepresets, *settings], outputs=settings)
+        savesets.click(fn=savepresets, inputs = [presetname,*settings],outputs=availablepresets)
+        
+        return [active, debug, rp_selected_tab, mmode, xmode, pmode, ratios, baseratios,
+                usebase, usecom, usencom, calcmode, nchangeand, lnter, lnur, threshold, polymask, lstop, lstop_hr, flipper]
+
+    def process(self, p, active, debug, rp_selected_tab, mmode, xmode, pmode, aratios, bratios,
+                usebase, usecom, usencom, calcmode, nchangeand, lnter, lnur, threshold, polymask, lstop, lstop_hr, flipper):
+        if type(polymask) == str:
+            try:
+                polymask,_,_ = draw_image(np.array(Image.open(polymask)))
+            except:
+                pass
+
+        if debug: pprint([active, debug, rp_selected_tab, mmode, xmode, pmode, aratios, bratios,
+                usebase, usecom, usencom, calcmode, nchangeand, lnter, lnur, threshold, polymask, lstop, lstop_hr, flipper])
+
+        tprompt = p.prompt[0] if type(p.prompt) == list else p.prompt
+        if not any(key in tprompt for key in ALLALLKEYS) or not active:
+            return unloader(self,p)
+
+        p.extra_generation_params.update({
+            "RP Active":active,
+            "RP Divide mode": rp_selected_tab,
+            "RP Matrix submode": mmode,
+            "RP Mask submode": xmode,
+            "RP Prompt submode": pmode,
+            "RP Calc Mode":calcmode,
+            "RP Ratios": aratios,
+            "RP Base Ratios": bratios,
+            "RP Use Base":usebase,
+            "RP Use Common":usecom,
+            "RP Use Ncommon": usencom,
+            "RP Change AND" : nchangeand,
+            "RP LoRA Neg Te Ratios": lnter,
+            "RP LoRA Neg U Ratios": lnur,
+            "RP threshold": threshold,
+            "RP LoRA Stop Step":lstop,
+            "RP LoRA Hires Stop Step":lstop_hr,
+            "RP Flip": flipper,
+        })
+
+        savepresets("lastrun",rp_selected_tab, mmode, xmode, pmode, aratios,bratios,
+                     usebase, usecom, usencom, calcmode, nchangeand, lnter, lnur, threshold, polymask,lstop, lstop_hr, flipper)
+
+        if flipper:aratios = changecs(aratios)
+
+        self.__init__(active, tabs2mode(rp_selected_tab, mmode, xmode, pmode) ,calcmode ,p.height, p.width, debug, usebase, usecom, usencom, p.batch_size, hasattr(shared.sd_model,"conditioner"),lstop, lstop_hr)
+        self.all_prompts = p.all_prompts.copy()
+        self.all_negative_prompts = p.all_negative_prompts.copy()
+
+        # SBM ddim / plms detection.
+        self.isvanilla = p.sampler_name in ["DDIM", "PLMS", "UniPC"]
+
+        if self.h % ATTNSCALE != 0 or self.w % ATTNSCALE != 0:
+            # Testing shows a round down occurs in model.
+            print("Warning: Nonstandard height / width.")
+            self.h = self.h - self.h % ATTNSCALE
+            self.w = self.w - self.w % ATTNSCALE
+
+        if hasattr(p,"enable_hr"): # Img2img doesn't have it.
+            self.hr = p.enable_hr
+            self.hr_w = (p.hr_resize_x if p.hr_resize_x > p.width else p.width * p.hr_scale)
+            self.hr_h = (p.hr_resize_y if p.hr_resize_y > p.height else p.height * p.hr_scale)
+            if self.hr_h % ATTNSCALE != 0 or self.hr_w % ATTNSCALE != 0:
+                # Testing shows a round down occurs in model.
+                print("Warning: Nonstandard height / width for ulscaled size")
+                self.hr_h = self.hr_h - self.hr_h % ATTNSCALE
+                self.hr_w = self.hr_w - self.hr_w % ATTNSCALE
+    
+        loraverchekcer(self)                                                  #check web-ui version
+        if not nchangeand: allchanger(p, "AND", KEYBRK)                                          #Change AND to BREAK
+        if any(x in self.mode for x in ["Ver","Hor"]):
+            keyconverter(aratios, self.mode, usecom, usebase, p) #convert BREAKs to ADDROMM/ADDCOL/ADDROW
+        bckeydealer(self, p)                                                      #detect COMM/BASE keys
+        keycounter(self, p)                                                       #count keys and set to self.divide
+            
+        if "Pro" not in self.mode: # skip region assign in prompt mode
+            ##### region mode
+            if "Mask" in self.mode:
+                keyreplacer(p) #change all keys to BREAK
+                inpaintmaskdealer(self, p, bratios, usebase, polymask)
+
+            elif any(x in self.mode for x in ["Ver","Hor","Ran"]):
+                matrixdealer(self, p, aratios, bratios, self.mode)
+    
+            ##### calcmode 
+            if "Att" in calcmode:
+                self.handle = hook_forwards(self, p.sd_model.model.diffusion_model)
+                if hasattr(shared.opts,"batch_cond_uncond"):
+                    shared.opts.batch_cond_uncond = orig_batch_cond_uncond
+                else:                    
+                    shared.batch_cond_uncond = orig_batch_cond_uncond
+                    
+            else:
+                self.handle = hook_forwards(self, p.sd_model.model.diffusion_model,remove = True)
+                setuploras(self)
+                # SBM It is vital to use local activation because callback registration is permanent,
+                # and there are multiple script instances (txt2img / img2img). 
+
+        elif "Pro" in self.mode: #Prompt mode use both calcmode
+            self.ex = "Ex" in self.mode
+            if not usebase : bratios = "0"
+            self.handle = hook_forwards(self, p.sd_model.model.diffusion_model)
+            denoiserdealer(self)
+
+        neighbor(self,p)                                                    #detect other extention
+        keyreplacer(p)                                                      #replace all keys to BREAK
+        commondealer(p, self.usecom, self.usencom)          #add commom prompt to all region
+        if "La" in self.calc: allchanger(p, KEYBRK,"AND")      #replace BREAK to AND in Latent mode
+        if tokendealer(self, p): return unloader(self,p)          #count tokens and calcrate target tokens
+        thresholddealer(self, p, threshold)                          #set threshold
+        
+        bratioprompt(self, bratios)
+        hrdealer(p)
+
+        print(f"Regional Prompter Active, Pos tokens : {self.ppt}, Neg tokens : {self.pnt}")
+        if debug : debugall(self)
+
+    def before_process_batch(self, p, *args, **kwargs):
+        if self.active:
+            self.current_prompts = kwargs["prompts"].copy()
+            p.disable_extra_networks = False
+
+    def before_hr(self, p, active, debug, rp_selected_tab, mmode, xmode, pmode, aratios, bratios,
+                      usebase, usecom, usencom, calcmode,nchangeand, lnter, lnur, threshold, polymask,lstop, lstop_hr, flipper):
+        if self.active:
+            self.in_hr = True
+            if "La" in self.calc:
+                setloradevice(self) #change lora device cup to gup and restore model in new web-ui lora method
+                lora_namer(self, p, lnter, lnur)
+                self.log["before_hr"] = "passed"
+                try:
+                    import lora
+                    self.log["before_hr_loralist"] = [x.name for x in lora.loaded_loras]
+                except:
+                    pass
+
+    def process_batch(self, p, active, debug, rp_selected_tab, mmode, xmode, pmode, aratios, bratios,
+                      usebase, usecom, usencom, calcmode,nchangeand, lnter, lnur, threshold, polymask,lstop, lstop_hr,flipper,**kwargs):
+        # print(kwargs["prompts"])
+        if self.active:
+            resetpcache(p)
+            self.in_hr = False
+            self.xsize = 0
+            # SBM Before_process_batch was added in feb-mar, adding fallback.
+            if not hasattr(self,"current_prompts"):
+                self.current_prompts = kwargs["prompts"].copy()
+            p.all_prompts[p.iteration * p.batch_size:(p.iteration + 1) * p.batch_size] = self.all_prompts[p.iteration * p.batch_size:(p.iteration + 1) * p.batch_size]
+            p.all_negative_prompts[p.iteration * p.batch_size:(p.iteration + 1) * p.batch_size] = self.all_negative_prompts[p.iteration * p.batch_size:(p.iteration + 1) * p.batch_size]
+            if "Pro" in self.mode:
+                reset_pmasks(self)
+            if "La" in self.calc:
+                setloradevice(self) #change lora device cup to gup and restore model in new web-ui lora method
+                lora_namer(self, p, lnter, lnur)
+                try:
+                    import lora
+                    self.log["loralist"] = [x.name for x in lora.loaded_loras]
+                except:
+                    pass
+
+                if self.lora_applied: # SBM Don't override orig twice on batch calls.
+                    pass
+                else:
+                    restoremodel(p)
+                    denoiserdealer(self)
+                    self.lora_applied = True
+                #escape reload loras in hires-fix
+
+    def postprocess(self, p, processed, *args):
+        if self.active : 
+            with open(os.path.join(paths.data_path, "params.txt"), "w", encoding="utf8") as file:
+                processedx = Processed(p, [], p.seed, "")
+                file.write(processedx.infotext(p, 0))
+        
+        if "Pro" in self.mode and not fseti("hidepmask"):
+            savepmasks(self, processed)
+
+        if self.debug : debugall(self)
+
+        unloader(self, p)
+
+    def denoiser_callback(self, params: CFGDenoiserParams):
+        denoiser_callback_s(self, params)
+
+    def denoised_callback(self, params: CFGDenoisedParams):
+        denoised_callback_s(self, params)
+
+
+def unloader(self,p):
+    if hasattr(self,"handle"):
+        print("unloaded")
+        hook_forwards(self, p.sd_model.model.diffusion_model, remove=True)
+        del self.handle
+
+    self.__init__()
+    
+    if hasattr(shared.opts,"batch_cond_uncond"):
+        shared.opts.batch_cond_uncond = orig_batch_cond_uncond
+    else:                    
+        shared.batch_cond_uncond = orig_batch_cond_uncond
+
+    unloadlorafowards(p)
+
+def denoiserdealer(self):
+    if self.calc =="Latent": # prompt mode use only denoiser callbacks
+        if not hasattr(self,"dd_callbacks"):
+            self.dd_callbacks = on_cfg_denoised(self.denoised_callback)
+        if hasattr(shared.opts,"batch_cond_uncond"):
+            shared.opts.batch_cond_uncond = False
+        else:                    
+            shared.batch_cond_uncond = False
+
+    if not hasattr(self,"dr_callbacks"):
+        self.dr_callbacks = on_cfg_denoiser(self.denoiser_callback)
+
+
+############################################################
+##### prompts, tokens
+def commondealer(p, usecom, usencom):
+    all_prompts = []
+    all_negative_prompts = []
+    def comadder(prompt):
+        ppl = prompt.split(KEYBRK)
+        for i in range(len(ppl)):
+            if i == 0:
+                continue
+            ppl[i] = ppl[0] + ", " + ppl[i]
+        ppl = ppl[1:]
+        prompt = f"{KEYBRK} ".join(ppl)
+        return prompt
+
+    if usecom:
+        for pr in p.all_prompts:
+            all_prompts.append(comadder(pr))
+        p.all_prompts = all_prompts
+        p.prompt = all_prompts[0]
+
+    if usencom:
+        for pr in p.all_negative_prompts:
+            all_negative_prompts.append(comadder(pr))
+        p.all_negative_prompts = all_negative_prompts
+        p.negative_prompt = all_negative_prompts[0]
+
+def hrdealer(p):
+    p.hr_prompt = p.prompt
+    p.hr_negative_prompt = p.negative_prompt
+    p.all_hr_prompts = p.all_prompts
+    p.all_hr_negative_prompts = p.all_negative_prompts
+
+def allchanger(p, a, b):
+    p.prompt = p.prompt.replace(a, b)
+    for i in lange(p.all_prompts):
+        p.all_prompts[i] = p.all_prompts[i].replace(a, b)
+    p.negative_prompt = p.negative_prompt.replace(a, b)
+    for i in lange(p.all_negative_prompts):
+        p.all_negative_prompts[i] = p.all_negative_prompts[i].replace(a, b)
+
+def tokendealer(self, p):
+    seps = "AND" if "La" in self.calc else KEYBRK
+    self.seps = seps
+    text, _ = extra_networks.parse_prompt(p.all_prompts[0]) # SBM From update_token_counter.
+    ppl = text.split(seps)
+    npl = p.all_negative_prompts[0].split(seps)
+    targets =[p.split(",")[-1] for p in ppl[1:]]
+    pt, nt, ppt, pnt, tt = [], [], [], [], []
+
+    padd = 0
+    
+    tokenizer = shared.sd_model.conditioner.embedders[0].tokenize_line if self.isxl else shared.sd_model.cond_stage_model.tokenize_line
+
+    for pp in ppl:
+        tokens, tokensnum = tokenizer(pp)
+        pt.append([padd, tokensnum // TOKENS + 1 + padd])
+        ppt.append(tokensnum)
+        padd = tokensnum // TOKENS + 1 + padd
+
+    if "Pro" in self.mode:
+        for target in targets:
+            ptokens, tokensnum = tokenizer(ppl[0])
+            ttokens, _ = tokenizer(target)
+
+            i = 1
+            tlist = []
+            while ttokens[0].tokens[i] != 49407:
+                for (j, maintok) in enumerate(ptokens): # SBM Long prompt.
+                    if ttokens[0].tokens[i] in maintok.tokens:
+                        tlist.append(maintok.tokens.index(ttokens[0].tokens[i]) + 75 * j)
+                i += 1
+            if tlist != [] : tt.append(tlist)
+
+    paddp = padd
+    padd = 0
+    for np in npl:
+        _, tokensnum = tokenizer(np)
+        nt.append([padd, tokensnum // TOKENS + 1 + padd])
+        pnt.append(tokensnum)
+        padd = tokensnum // TOKENS + 1 + padd
+
+    self.eq = paddp == padd
+
+    self.pt = pt
+    self.nt = nt
+    self.pe = tt
+    self.ppt = ppt
+    self.pnt = pnt
+
+    notarget = "Pro" in self.mode and tt == []
+    if notarget:
+        print("No target word is detected in Prompt mode")
+    return notarget
+
+def thresholddealer(self, p ,threshold):
+    if "Pro" in self.mode:
+        threshold = threshold.split(",")
+        while len(self.pe) >= len(threshold) + 1:
+            threshold.append(threshold[0])
+        self.th = [floatdef(t, 0.4) for t in threshold] * self.batch_size
+        if self.debug :print ("threshold", self.th)
+
+def bratioprompt(self, bratios):
+    if not "Pro" in self.mode: return self
+    bratios = bratios.split(",")
+    bratios = [floatdef(b, 0) for b in bratios]
+    while len(self.pe) >= len(bratios) + 1:
+        bratios.append(bratios[0])
+    self.bratios = bratios
+
+def neighbor(self,p):
+    from modules.scripts import scripts_txt2img
+    for script in scripts_txt2img.alwayson_scripts:
+        if "negpip.py" in script.filename:
+            self.negpip = script
+
+    try:
+        args = p.script_args
+        multi = ["MultiDiffusion",'Mixture of Diffusers']
+        if any(x in args for x in multi):
+            for key in multi:
+                if key in args:
+                    self.nei_multi = [args[args.index(key)+5],args[args.index(key)+6]]
+    except:
+        pass
+
+#####################################################
+##### Presets - Save  and Load Settings
+
+fimgpt = lambda flnm, fext, *dirparts: os.path.join(*dirparts, flnm + fext)
+
+class PresetList():
+    """Preset list must be the same object throughout its lifetime, otherwise updates will err.
+
+    See gradio issue #4210 for details.
+    """
+    def __init__(self):
+        self.lpr = []
+    
+    def update(self, newpr):
+        """Replace all values, return the reference.
+        
+        Will convert dicts to the names only.
+        Might be more efficient to add the new names only, but meh.
+        """
+        if len(newpr) > 0 and isinstance(newpr[0],dict):
+            newpr = [pr["name"] for pr in newpr] 
+        self.lpr.clear()
+        self.lpr.extend(newpr)
+        return self.lpr
+        
+    def get(self):
+        return self.lpr
+
+class JsonMask():
+    """Mask saved as image with some editing work.
+    
+    """
+    blobdir = "regional_masks"
+    ext = ".png"
+    
+    def __init__(self, img):
+        self.img = img
+    
+    def makepath(self, name):
+        pt = fimgpt(name, self.ext, PTPRESET, self.blobdir)
+        os.makedirs(os.path.dirname(pt), exist_ok = True)
+        return pt
+    
+    def save(self, name, preset = None):
+        """Save image to subdir.
+        
+        Only saved when in mask mode - Hardcoded, don't have a better idea atm.
+        """
+        if (preset is None) or (preset[1] == "Mask"): # Check mode.  
+            save_mask(self.img, self.makepath(name))
+            return name
+        return None
+    
+    def load(self, name, preset = None):
+        """Load image from subdir (no editing, that comes later).
+        
+        Prefer to use the given key, rather than name. SBM CONT: Load / save in dict mode? Debugging needed.
+        """
+        if name is None or self.img is None:
+            return None
+        return load_mask(self.makepath(self.img))
+
+LPRESET = PresetList()
+
+fcountbrk = lambda x: x.count(KEYBRK)
+fint = lambda x: int(x)
+
+# Json formatters.
+fjstr = lambda x: x.strip()
+#fjbool = lambda x: (x.upper() == "TRUE" or x.upper() == "T")
+fjbool = lambda x: x # Json can store booleans reliably.
+fjmask = lambda x: draw_image(x, inddict = False)[0] # Ignore mask reset value. 
+
+# (json_name, value_format, default)
+# If default = none then will use current gradio value. 
+PRESET_KEYS = [
+("name",fjstr,"") , # Name is special, preset's key.
+("mode", fjstr, None) ,
+("ratios", fjstr, None) ,
+("baseratios", fjstr, None) ,
+("usebase", fjbool, None) ,
+("usecom", fjbool, False) ,
+("usencom", fjbool, False) ,
+("calcmode", fjstr, "Attention") , # Generation mode.
+("nchangeand", fjbool, False) ,
+("lnter", fjstr, "0") ,
+("lnur", fjstr, "0") ,
+("threshold", fjstr, "0") ,
+("polymask", fjmask, "") , # Mask has special corrections and logging.
+]
+# (json_name,blob_class)
+# Handles save + lazy load of blob data outside of presets.
+BLOB_KEYS = {
+"polymask": JsonMask
+}
+
+def saveblob(preset):
+    """Preset variables saved externally (blob).
+    
+    Returns modified list containing the refernces instead of data.
+    Currently, this includes polymask, which is saved as an image,
+    with a filename = preset.
+    A blob class should contain a save method which returns the reference. 
+    """
+    preset = list(preset) # Tuples don't have copy.
+    for (i,(vkey,vfun,vdef)) in enumerate(PRESET_KEYS):
+        if vkey in BLOB_KEYS:
+            # Func should accept raw form and convert it to a class.
+            x = BLOB_KEYS[vkey](preset[i])
+            # Class should have a save func given identifier, returning an access key.
+            x = x.save(preset[0], preset)
+            # Update the preset.
+            preset[i] = x
+    return preset
+
+def loadblob(preset):
+    """Load blob presets based on key.
+    
+    Returns modified list containing the refernces instead of 
+    Currently, this includes polymask, which is saved as an image,
+    with a filename = preset.
+    A blob class should contain a load method which retrieves the data based on reference. 
+    """
+    for (vkey,vval) in BLOB_KEYS.items():
+        # Func should accept refrence form and convert it to a class.
+        x = vval(preset.get(vkey))
+        # Class should have a load func given identifier, returning data.
+        x = x.load(preset["name"], preset)
+        # Update the preset.
+        preset[vkey] = x
+    return preset
+
+def savepresets(*settings):
+    # NAME must come first.
+    name = settings[0]
+    settings = [name] + compress_components(settings[1:])
+    settings = saveblob(settings)
+    
+    # path_root = modules.scripts.basedir()
+    # filepath = os.path.join(path_root, "scripts", "regional_prompter_presets.json")
+    filepath = os.path.join(PTPRESET, FLJSON)
+
+    try:
+        with open(filepath, mode='r', encoding="utf-8") as f:
+            # presets = json.loads(json.load(f))
+            presets = json.load(f)
+            pr = {PRESET_KEYS[i][0]:settings[i] for i,_ in enumerate(PRESET_KEYS)}
+            # SBM Ordereddict might be better than list, quick search.
+            written = False
+            # if name == "lastrun": # SBM We should check the preset is unique in any case.
+            for i, preset in enumerate(presets):
+                if name == preset["name"]:
+                # if "lastrun" in preset["name"]:
+                    presets[i] = pr
+                    written = True
+            if not written:
+                presets.append(pr)
+        with open(filepath, mode='w', encoding="utf-8") as f:
+            # json.dump(json.dumps(presets), f, indent = 2)
+            json.dump(presets, f, indent = 2)
+    except Exception as e:
+        print(e)
+
+    presets = loadpresets(filepath)
+    presets = LPRESET.update(presets)
+    return gr.update(choices=presets)
+
+def presetfallback():
+    """Swaps main json dir to alt if exists, attempts reload.
+    
+    """
+    global PTPRESET
+    global PTPRESETALT
+    
+    if PTPRESETALT is not None:
+        print("Unknown preset error, fallback.")
+        PTPRESET = PTPRESETALT
+        PTPRESETALT = None
+        return loadpresets(PTPRESET)
+    else: # Already attempted swap.
+        print("Presets could not be loaded.") 
+        return None
+
+def loadpresets(filepath):
+    presets = []
+    try:
+        with open(filepath, encoding="utf-8") as f:
+            # presets = json.loads(json.load(f))
+            presets = json.load(f)
+            # presets = loadblob(presets) # DO NOT load all blobs - that's the point.
+    except OSError as e:
+        print("Init / preset error.")
+        presets = initpresets(filepath)
+    except TypeError:
+        print("Corrupted preset file, resetting.")
+        presets = initpresets(filepath)
+    except JSONDecodeError:
+        print("Preset file could not be decoded.")
+        presets = initpresets(filepath)
+    return presets
+
+def initpresets(filepath):
+    lpr = PRESETSDEF
+    # if not os.path.isfile(filepath):
+    try:
+        with open(filepath, mode='w', encoding="utf-8") as f:
+            lprj = []
+            for pr in lpr:
+                plen = min(len(PRESET_KEYS), len(pr)) # Future setting additions ignored.
+                prj = {PRESET_KEYS[i][0]:pr[i] for i in range(plen)}
+                lprj.append(prj)
+            #json.dump(json.dumps(lprj), f, indent = 2)
+            json.dump(lprj, f, indent = 2)
+            return lprj
+    except Exception as e:
+        return presetfallback()
+
+#####################################################
+##### Global settings
+
+EXTKEY = "regprp"
+EXTNAME = "Regional Prompter"
+# (id, label, type, extra_parms)
+EXTSETS = [
+("debug", "(PLACEHOLDER, USE THE ONE IN 2IMG) Enable debug mode", "check", dict()),
+("hidepmask", "Hide subprompt masks in prompt mode", "check", dict()),
+
+]
+# Dynamically constructed list of default values, because shared doesn't allocate a value automatically.
+# (id: def)
+DEXTSETV = dict()
+fseti = lambda x: shared.opts.data.get(EXTKEY + "_" + x, DEXTSETV[x])
+
+class Setting_Component():
+    """Creates gradio components with some standard req values.
+    
+    All must supply an id (used in code), label, component type. 
+    Default value and specific type settings can be overridden. 
+    """
+    section = (EXTKEY, EXTNAME)
+    def __init__(self, cid, clabel, ctyp, vdef = None, **kwargs):
+        self.cid = EXTKEY + "_" + cid
+        self.clabel = clabel
+        self.ctyp = ctyp
+        method = getattr(self, self.ctyp)
+        method(**kwargs)
+        if vdef is not None:
+            self.vdef = vdef
+        
+    def get(self):
+        """Get formatted setting.
+        
+        Input for shared.opts.add_option().
+        """
+        if self.ctyp == "textb":
+            return (self.cid, shared.OptionInfo(self.vdef, self.clabel, section = self.section))
+        return (self.cid, shared.OptionInfo(self.vdef, self.clabel,
+                                            self.ccomp, self.cparms, section = self.section))
+    
+    def textb(self, **kwargs):
+        """Textbox unusually requires no component.
+        
+        """
+        self.ccomp = gr.Textbox
+        self.vdef = ""
+        self.cparms = {}
+        self.cparms.update(kwargs)
+    
+    def check(self, **kwargs):
+        self.ccomp = gr.Checkbox
+        self.vdef = False
+        self.cparms = {"interactive": True}
+        self.cparms.update(kwargs)
+        
+    def slider(self, **kwargs):
+        self.ccomp = gr.Slider
+        self.vdef = 0
+        self.cparms = {"minimum": 1, "maximum": 10, "step": 1}
+        self.cparms.update(kwargs)
+
+def ext_on_ui_settings():
+    for (cid, clabel, ctyp, kwargs) in EXTSETS:
+        comp = Setting_Component(cid, clabel, ctyp, **kwargs)
+        opt = comp.get()
+        shared.opts.add_option(*opt)
+        DEXTSETV[cid] = comp.vdef
+
+def debugall(self):
+    print(f"mode : {self.mode}\ncalcmode : {self.calc}\nusebase : {self.usebase}")
+    print(f"base ratios : {self.bratios}\nusecommon : {self.usecom}\nusenegcom : {self.usencom}")
+    print(f"divide : {self.divide}\neq : {self.eq}")
+    print(f"tokens : {self.ppt},{self.pnt},{self.pt},{self.nt}")
+    print(f"ratios : {self.aratios}\n")
+    print(f"prompt : {self.pe}")
+    print(f"env : before15:{self.isbefore15},isxl:{self.isxl}")
+    print(f"loras{self.log}")
+
+def bckeydealer(self, p):
+    '''
+    detect COMM/BASE keys and set flags and change to BREAK
+    '''
+    if KEYCOMM in p.prompt:
+        self.usecom = True
+    if self.usecom and KEYCOMM not in p.prompt:
+        p.prompt = p.prompt.replace(KEYBRK,KEYCOMM,1)
+    
+    if KEYCOMM in p.negative_prompt:
+        self.usencom = True
+    if self.usencom and KEYCOMM not in p.negative_prompt:
+        p.negative_prompt = p.negative_prompt.replace(KEYBRK,KEYCOMM,1)
+    
+    if KEYBASE in p.prompt:
+        self.usebase = True
+    if self.usebase and KEYBASE not in p.prompt:
+        p.prompt = p.prompt.replace(KEYBRK,KEYBASE,1)
+        
+    if KEYPROMPT in p.prompt.upper():
+        self.mode = "Prompt"
+
+def keyconverter(aratios,mode,usecom,usebase,p):
+    '''convert BREAKS to ADDCOMM/ADDBASE/ADDCOL/ADDROW'''
+    keychanger = makeimgtmp(aratios,mode,usecom,usebase,False, inprocess = True)
+    keychanger = keychanger[:-1]
+    #print(keychanger,p.prompt)
+    for change in keychanger:
+        if change == KEYCOMM and KEYCOMM in p.prompt: continue
+        if change == KEYBASE and KEYBASE in p.prompt: continue
+        p.prompt= p.prompt.replace(KEYBRK,change,1)
+
+def keyreplacer(p):
+    '''
+    replace all separators to BREAK
+    p.all_prompt and p.all_negative_prompt
+    '''
+    for key in ALLKEYS:
+        for i in lange(p.all_prompts):
+            p.all_prompts[i]= p.all_prompts[i].replace(key,KEYBRK)
+        
+        for i in lange(p.all_negative_prompts):
+            p.all_negative_prompts[i] = p.all_negative_prompts[i].replace(key,KEYBRK)
+
+def keycounter(self, p):
+    pc = sum([p.prompt.count(text) for text in ALLALLKEYS])
+    npc = sum([p.negative_prompt.count(text) for text in ALLALLKEYS])
+    self.divide = [pc + 1, npc + 1]
+
+def resetpcache(p):
+    p.cached_c = [None,None]
+    p.cached_uc = [None,None]
+    p.cached_hr_c = [None, None]
+    p.cached_hr_uc = [None, None]
+
+def loraverchekcer(self):
+    try:
+        self.ui_version = int(launch.git_tag().replace("v","").replace(".",""))
+    except:
+        self.ui_version = 100
+        
+    try:
+        import lora
+        self.isbefore15 =  "assign_lora_names_to_compvis_modules" in dir(lora)
+        self.layer_name = "lora_layer_name" if self.isbefore15 else "network_layer_name"
+    except:
+        self.isbefore15 = False
+        self.layer_name = "lora_layer_name"
+
+on_ui_settings(ext_on_ui_settings)

regional-prompter-main/style.css

@@ -0,0 +1,6 @@
+#polymask, #polymask > .h-60, #polymask > .h-60 > div, #polymask > .h-60 > div > img
+{
+    height: 512px !important;
+    max-height: 512px !important;
+    min-height: 512px !important;
+}