ci: fix tag condition

- ok i didnt expect github actions does not support regex wtf

.github/workflows/build-and-draft-release.yml

@@ -0,0 +1,39 @@
+name: "Build and draft a release"
+
+on:
+  workflow_dispatch:
+  push:
+    tags:
+      - '*.*.*'
+
+permissions:
+  contents: write
+  discussions: write
+
+jobs:
+  build-and-draft-release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python environment
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+
+      - name: Build package
+        run: |
+          pip install build
+          python -m build
+
+      - name: Draft a release
+        uses: softprops/action-gh-release@v2
+        with:
+          discussion_category_name: New releases
+          draft: true
+          generate_release_notes: true
+          files: |
+            dist/*

.gitignore

@@ -1,6 +1,8 @@
 __debug*
 .vscode/
 
+*venv*/
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]

.pre-commit-config.yaml

@@ -4,13 +4,10 @@ repos:
     hooks:
       - id: end-of-file-fixer
       - id: trailing-whitespace
-  - repo: https://github.com/psf/black
+
-    rev: 23.1.0
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.11.13
     hooks:
-      - id: black
+      - id: ruff
-        exclude: _builtin_templates.py
+        args: ["--fix"]
-  - repo: https://github.com/PyCQA/isort
+      - id: ruff-format
-    rev: 5.12.0
-    hooks:
-      - id: isort
-        exclude: _builtin_templates.py

LICENSE

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

README.md

@@ -3,26 +3,49 @@
 ## Example
 
 ```py
-from arcaea_offline_ocr.device.v2.rois import DeviceV2AutoRois
-from arcaea_offline_ocr.device.v2.ocr import DeviceV2Ocr
-from arcaea_offline_ocr.sift_db import SIFTDatabase
-from arcaea_offline_ocr.utils import imread_unicode
 import cv2
+from arcaea_offline_ocr.device.ocr import DeviceOcr
+from arcaea_offline_ocr.device.rois.definition import DeviceRoisAutoT2
+from arcaea_offline_ocr.device.rois.extractor import DeviceRoisExtractor
+from arcaea_offline_ocr.device.rois.masker import DeviceRoisMaskerAutoT2
+from arcaea_offline_ocr.phash_db import ImagePhashDatabase
 
-knn_model = cv2.ml.KNearest_load(r'/path/to/knn/model')
+img_path = "/path/to/opencv/supported/image/formats.jpg"
-sift_db = SIFTDatabase(r'/path/to/sift/database.db')
+img = cv2.imread(img_path, cv2.IMREAD_COLOR)
 
-rois = DeviceV2AutoRois(imread_unicode(r'/path/to/your/screenshot.jpg'))  # any format that opencv-python supports
+rois = DeviceRoisAutoT2(img.shape[1], img.shape[0])
-ocr = DeviceV2Ocr(knn_model, sift_db)
+extractor = DeviceRoisExtractor(img, rois)
-result = ocr.ocr(rois)
+masker = DeviceRoisMaskerAutoT2()
-print(result)
+
+knn_model = cv2.ml.KNearest.load("/path/to/trained/knn/model.dat")
+phash_db = ImagePhashDatabase("/path/to/image/phash/database.db")
+
+ocr = DeviceOcr(extractor, masker, knn_model, phash_db)
+print(ocr.ocr())
 ```
 
 ```sh
 $ python example.py
-DeviceOcrResult(rating_class=2, pure=1371, far=62, lost=34, score=9558078, max_recall=330, song_id='abstrusedilemma', title=None, clear_type=None)
+DeviceOcrResult(rating_class=2, pure=1135, far=11, lost=0, score=9953016, max_recall=1146, song_id='ringedgenesis', song_id_possibility=0.953125, clear_status=2, partner_id='45', partner_id_possibility=0.8046875)
 ```
 
+## License
+
+This file is part of arcaea-offline-ocr, as called "This program" below.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
 ## Credits
 
-[283375/image-sift-database](https://github.com/283375/image-sift-database)
+[283375/image-phash-database](https://github.com/283375/image-phash-database)

pyproject.toml

@@ -1,23 +1,26 @@
 [build-system]
-requires = ["setuptools>=61.0"]
+requires = ["setuptools>=64", "setuptools-scm>=8"]
 build-backend = "setuptools.build_meta"
 
 [project]
+dynamic = ["version"]
+
 name = "arcaea-offline-ocr"
-version = "0.1.0"
 authors = [{ name = "283375", email = "log_283375@163.com" }]
 description = "Extract your Arcaea play result from screenshot."
 readme = "README.md"
 requires-python = ">=3.8"
-dependencies = ["attrs==23.1.0", "numpy==1.25.2", "opencv-python==4.8.0.76"]
+dependencies = ["attrs==23.1.0", "numpy==1.26.1", "opencv-python==4.8.1.78"]
 classifiers = [
   "Development Status :: 3 - Alpha",
   "Programming Language :: Python :: 3",
 ]
 
 [project.urls]
-"Homepage" = "https://github.com/283375/arcaea-offline-ocr"
+"Homepage" = "https://github.com/ArcaeaOffline/core-ocr"
-"Bug Tracker" = "https://github.com/283375/arcaea-offline-ocr/issues"
+"Bug Tracker" = "https://github.com/ArcaeaOffline/core-ocr/issues"
+
+[tool.setuptools_scm]
 
 [tool.isort]
 profile = "black"
@@ -25,3 +28,14 @@ src_paths = ["src/arcaea_offline_ocr"]
 
 [tool.pyright]
 ignore = ["**/__debug*.*"]
+
+[tool.pylint.main]
+# extension-pkg-allow-list = ["cv2"]
+generated-members = ["cv2.*"]
+
+[tool.pylint.logging]
+disable = [
+  "missing-module-docstring",
+  "missing-class-docstring",
+  "missing-function-docstring",
+]

requirements.txt

@@ -1,3 +1,2 @@
-attrs==23.1.0
+numpy~=2.3
-numpy==1.25.2
+opencv-python~=4.11
-opencv-python==4.8.0.76

src/arcaea_offline_ocr/__init__.py

@@ -1,5 +0,0 @@
-from .crop import *
-from .device import *
-from .mask import *
-from .ocr import *
-from .utils import *

src/arcaea_offline_ocr/b30/shared.py

@@ -1,16 +0,0 @@
-from datetime import datetime
-from typing import Optional, Union
-
-import attrs
-
-
-@attrs.define
-class B30OcrResultItem:
-    rating_class: int
-    score: int
-    pure: Optional[int] = None
-    far: Optional[int] = None
-    lost: Optional[int] = None
-    date: Optional[datetime] = None
-    title: Optional[str] = None
-    song_id: Optional[str] = None

src/arcaea_offline_ocr/builders/__init__.py

@@ -0,0 +1,6 @@
+from .ihdb import ImageHashDatabaseBuildTask, ImageHashesDatabaseBuilder
+
+__all__ = [
+    "ImageHashDatabaseBuildTask",
+    "ImageHashesDatabaseBuilder",
+]

src/arcaea_offline_ocr/builders/ihdb.py

@@ -0,0 +1,112 @@
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Callable, List
+
+import cv2
+
+from arcaea_offline_ocr.core import hashers
+from arcaea_offline_ocr.providers import ImageCategory
+from arcaea_offline_ocr.providers.ihdb import (
+    PROP_KEY_BUILT_AT,
+    PROP_KEY_HASH_SIZE,
+    PROP_KEY_HIGH_FREQ_FACTOR,
+    ImageHashDatabaseIdProvider,
+    ImageHashType,
+)
+
+if TYPE_CHECKING:
+    from sqlite3 import Connection
+
+    from arcaea_offline_ocr.types import Mat
+
+
+def _default_imread_gray(image_path: str):
+    return cv2.cvtColor(cv2.imread(image_path, cv2.IMREAD_COLOR), cv2.COLOR_BGR2GRAY)
+
+
+@dataclass
+class ImageHashDatabaseBuildTask:
+    image_path: str
+    image_id: str
+    category: ImageCategory
+    imread_function: Callable[[str], "Mat"] = _default_imread_gray
+
+
+@dataclass
+class _ImageHash:
+    image_id: str
+    category: ImageCategory
+    image_hash_type: ImageHashType
+    hash: bytes
+
+
+class ImageHashesDatabaseBuilder:
+    @staticmethod
+    def __insert_property(conn: "Connection", key: str, value: str):
+        return conn.execute(
+            "INSERT INTO properties (key, value) VALUES (?, ?)",
+            (key, value),
+        )
+
+    @classmethod
+    def build(
+        cls,
+        conn: "Connection",
+        tasks: List[ImageHashDatabaseBuildTask],
+        *,
+        hash_size: int = 16,
+        high_freq_factor: int = 4,
+    ):
+        hashes: List[_ImageHash] = []
+
+        for task in tasks:
+            img_gray = task.imread_function(task.image_path)
+
+            for hash_type, hash_mat in [
+                (
+                    ImageHashType.AVERAGE,
+                    hashers.average(img_gray, hash_size),
+                ),
+                (
+                    ImageHashType.DCT,
+                    hashers.dct(img_gray, hash_size, high_freq_factor),
+                ),
+                (
+                    ImageHashType.DIFFERENCE,
+                    hashers.difference(img_gray, hash_size),
+                ),
+            ]:
+                hashes.append(
+                    _ImageHash(
+                        image_id=task.image_id,
+                        image_hash_type=hash_type,
+                        category=task.category,
+                        hash=ImageHashDatabaseIdProvider.hash_mat_to_bytes(hash_mat),
+                    )
+                )
+
+        conn.execute("CREATE TABLE properties (`key` VARCHAR, `value` VARCHAR)")
+        conn.execute(
+            """CREATE TABLE hashes (
+`id` VARCHAR,
+`category` INTEGER,
+`hash_type` INTEGER,
+`hash` BLOB
+)"""
+        )
+
+        now = datetime.now(tz=timezone.utc)
+        timestamp = int(now.timestamp() * 1000)
+
+        cls.__insert_property(conn, PROP_KEY_HASH_SIZE, str(hash_size))
+        cls.__insert_property(conn, PROP_KEY_HIGH_FREQ_FACTOR, str(high_freq_factor))
+        cls.__insert_property(conn, PROP_KEY_BUILT_AT, str(timestamp))
+
+        conn.executemany(
+            "INSERT INTO hashes (`id`, `category`, `hash_type`, `hash`) VALUES (?, ?, ?, ?)",
+            [
+                (it.image_id, it.category.value, it.image_hash_type.value, it.hash)
+                for it in hashes
+            ],
+        )
+        conn.commit()

src/arcaea_offline_ocr/core/hashers/__init__.py

@@ -0,0 +1,3 @@
+from .index import average, dct, difference
+
+__all__ = ["average", "dct", "difference"]

src/arcaea_offline_ocr/core/hashers/_common.py

@@ -0,0 +1,7 @@
+import cv2
+
+from arcaea_offline_ocr.types import Mat
+
+
+def _resize_image(src: Mat, dsize: ...) -> Mat:
+    return cv2.resize(src, dsize, fx=0, fy=0, interpolation=cv2.INTER_AREA)

src/arcaea_offline_ocr/core/hashers/index.py

@@ -0,0 +1,35 @@
+import cv2
+import numpy as np
+
+from arcaea_offline_ocr.types import Mat
+
+from ._common import _resize_image
+
+
+def average(img_gray: Mat, hash_size: int) -> Mat:
+    img_resized = _resize_image(img_gray, (hash_size, hash_size))
+    diff = img_resized > img_resized.mean()
+    return diff.flatten()
+
+
+def difference(img_gray: Mat, hash_size: int) -> Mat:
+    img_size = (hash_size + 1, hash_size)
+    img_resized = _resize_image(img_gray, img_size)
+
+    previous = img_resized[:, :-1]
+    current = img_resized[:, 1:]
+    diff = previous > current
+    return diff.flatten()
+
+
+def dct(img_gray: Mat, hash_size: int = 16, high_freq_factor: int = 4) -> Mat:
+    # TODO: consistency?
+    img_size_base = hash_size * high_freq_factor
+    img_size = (img_size_base, img_size_base)
+
+    img_resized = _resize_image(img_gray, img_size)
+    img_resized = img_resized.astype(np.float32)
+    dct_mat = cv2.dct(img_resized)
+
+    hash_mat = dct_mat[:hash_size, :hash_size]
+    return hash_mat > hash_mat.mean()

src/arcaea_offline_ocr/crop.py

@@ -1,11 +1,12 @@
-from math import floor
+import math
 from typing import Tuple
 
+import cv2
 import numpy as np
 
 from .types import Mat
 
-__all__ = ["crop_xywh", "crop_black_edges", "crop_black_edges_grayscale"]
+__all__ = ["crop_xywh", "CropBlackEdges"]
 
 
 def crop_xywh(mat: Mat, rect: Tuple[int, int, int, int]):
@@ -13,92 +14,53 @@ def crop_xywh(mat: Mat, rect: Tuple[int, int, int, int]):
     return mat[y : y + h, x : x + w]
 
 
-def is_black_edge(list_of_pixels: Mat, black_pixel: Mat, ratio: float = 0.6):
+class CropBlackEdges:
-    pixels = list_of_pixels.reshape([-1, 3])
+    @staticmethod
-    return np.count_nonzero(np.all(pixels < black_pixel, axis=1)) > floor(
+    def is_black_edge(__img_gray_slice: Mat, black_pixel: int, ratio: float = 0.6):
-        len(pixels) * ratio
+        pixels_compared = __img_gray_slice < black_pixel
-    )
+        return np.count_nonzero(pixels_compared) > math.floor(
+            __img_gray_slice.size * ratio
+        )
 
+    @classmethod
+    def get_crop_rect(cls, img_gray: Mat, black_threshold: int = 25):
+        height, width = img_gray.shape[:2]
+        left = 0
+        right = width
+        top = 0
+        bottom = height
 
-def crop_black_edges(img_bgr: Mat, black_threshold: int = 50):
+        for i in range(width):
-    cropped = img_bgr.copy()
+            column = img_gray[:, i]
-    black_pixel = np.array([black_threshold] * 3, img_bgr.dtype)
+            if not cls.is_black_edge(column, black_threshold):
-    height, width = img_bgr.shape[:2]
+                break
-    left = 0
+            left += 1
-    right = width
-    top = 0
-    bottom = height
 
-    for i in range(width):
+        for i in sorted(range(width), reverse=True):
-        column = cropped[:, i]
+            column = img_gray[:, i]
-        if not is_black_edge(column, black_pixel):
+            if i <= left + 1 or not cls.is_black_edge(column, black_threshold):
-            break
+                break
-        left += 1
+            right -= 1
 
-    for i in sorted(range(width), reverse=True):
+        for i in range(height):
-        column = cropped[:, i]
+            row = img_gray[i]
-        if i <= left + 1 or not is_black_edge(column, black_pixel):
+            if not cls.is_black_edge(row, black_threshold):
-            break
+                break
-        right -= 1
+            top += 1
 
-    for i in range(height):
+        for i in sorted(range(height), reverse=True):
-        row = cropped[i]
+            row = img_gray[i]
-        if not is_black_edge(row, black_pixel):
+            if i <= top + 1 or not cls.is_black_edge(row, black_threshold):
-            break
+                break
-        top += 1
+            bottom -= 1
 
-    for i in sorted(range(height), reverse=True):
+        assert right > left, "cropped width < 0"
-        row = cropped[i]
+        assert bottom > top, "cropped height < 0"
-        if i <= top + 1 or not is_black_edge(row, black_pixel):
+        return (left, top, right - left, bottom - top)
-            break
-        bottom -= 1
 
-    return cropped[top:bottom, left:right]
+    @classmethod
-
+    def crop(
-
+        cls, img: Mat, convert_flag: cv2.COLOR_BGR2GRAY, black_threshold: int = 25
-def is_black_edge_grayscale(
+    ) -> Mat:
-    gray_value_list: np.ndarray, black_threshold: int = 50, ratio: float = 0.6
+        rect = cls.get_crop_rect(cv2.cvtColor(img, convert_flag), black_threshold)
-) -> bool:
+        return crop_xywh(img, rect)
-    return (
-        np.count_nonzero(gray_value_list < black_threshold)
-        > len(gray_value_list) * ratio
-    )
-
-
-def crop_black_edges_grayscale(
-    img_gray: Mat, black_threshold: int = 50
-) -> Tuple[int, int, int, int]:
-    """Returns cropped rect"""
-    height, width = img_gray.shape[:2]
-    left = 0
-    right = width
-    top = 0
-    bottom = height
-
-    for i in range(width):
-        column = img_gray[:, i]
-        if not is_black_edge_grayscale(column, black_threshold):
-            break
-        left += 1
-
-    for i in sorted(range(width), reverse=True):
-        column = img_gray[:, i]
-        if i <= left + 1 or not is_black_edge_grayscale(column, black_threshold):
-            break
-        right -= 1
-
-    for i in range(height):
-        row = img_gray[i]
-        if not is_black_edge_grayscale(row, black_threshold):
-            break
-        top += 1
-
-    for i in sorted(range(height), reverse=True):
-        row = img_gray[i]
-        if i <= top + 1 or not is_black_edge_grayscale(row, black_threshold):
-            break
-        bottom -= 1
-
-    assert right > left, "cropped width > 0"
-    assert bottom > top, "cropped height > 0"
-    return (left, top, right - left, bottom - top)

src/arcaea_offline_ocr/device/shared.py

@@ -1,16 +0,0 @@
-from typing import Optional
-
-import attrs
-
-
-@attrs.define
-class DeviceOcrResult:
-    rating_class: int
-    pure: int
-    far: int
-    lost: int
-    score: int
-    max_recall: int
-    song_id: Optional[str] = None
-    title: Optional[str] = None
-    clear_type: Optional[str] = None

src/arcaea_offline_ocr/device/v1/crop.py

@@ -1,53 +0,0 @@
-from typing import Tuple
-
-from ...types import Mat
-from .definition import DeviceV1
-
-__all__ = [
-    "crop_img",
-    "crop_from_device_attr",
-    "crop_to_pure",
-    "crop_to_far",
-    "crop_to_lost",
-    "crop_to_max_recall",
-    "crop_to_rating_class",
-    "crop_to_score",
-    "crop_to_title",
-]
-
-
-def crop_img(img: Mat, *, top: int, left: int, bottom: int, right: int):
-    return img[top:bottom, left:right]
-
-
-def crop_from_device_attr(img: Mat, rect: Tuple[int, int, int, int]):
-    x, y, w, h = rect
-    return crop_img(img, top=y, left=x, bottom=y + h, right=x + w)
-
-
-def crop_to_pure(screenshot: Mat, device: DeviceV1):
-    return crop_from_device_attr(screenshot, device.pure)
-
-
-def crop_to_far(screenshot: Mat, device: DeviceV1):
-    return crop_from_device_attr(screenshot, device.far)
-
-
-def crop_to_lost(screenshot: Mat, device: DeviceV1):
-    return crop_from_device_attr(screenshot, device.lost)
-
-
-def crop_to_max_recall(screenshot: Mat, device: DeviceV1):
-    return crop_from_device_attr(screenshot, device.max_recall)
-
-
-def crop_to_rating_class(screenshot: Mat, device: DeviceV1):
-    return crop_from_device_attr(screenshot, device.rating_class)
-
-
-def crop_to_score(screenshot: Mat, device: DeviceV1):
-    return crop_from_device_attr(screenshot, device.score)
-
-
-def crop_to_title(screenshot: Mat, device: DeviceV1):
-    return crop_from_device_attr(screenshot, device.title)

src/arcaea_offline_ocr/device/v1/definition.py

@@ -1,37 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, Dict, Tuple
-
-__all__ = ["DeviceV1"]
-
-
-@dataclass(kw_only=True)
-class DeviceV1:
-    version: int
-    uuid: str
-    name: str
-    pure: Tuple[int, int, int, int]
-    far: Tuple[int, int, int, int]
-    lost: Tuple[int, int, int, int]
-    max_recall: Tuple[int, int, int, int]
-    rating_class: Tuple[int, int, int, int]
-    score: Tuple[int, int, int, int]
-    title: Tuple[int, int, int, int]
-
-    @classmethod
-    def from_json_object(cls, json_dict: Dict[str, Any]):
-        if json_dict["version"] == 1:
-            return cls(
-                version=1,
-                uuid=json_dict["uuid"],
-                name=json_dict["name"],
-                pure=json_dict["pure"],
-                far=json_dict["far"],
-                lost=json_dict["lost"],
-                max_recall=json_dict["max_recall"],
-                rating_class=json_dict["rating_class"],
-                score=json_dict["score"],
-                title=json_dict["title"],
-            )
-
-    def repr_info(self):
-        return f"Device(version={self.version}, uuid={repr(self.uuid)}, name={repr(self.name)})"

src/arcaea_offline_ocr/device/v1/ocr.py

@@ -1,86 +0,0 @@
-from typing import List
-
-import cv2
-
-from ...crop import crop_xywh
-from ...mask import mask_gray, mask_white
-from ...ocr import ocr_digits_by_contour_knn, ocr_rating_class
-from ...types import Mat, cv2_ml_KNearest
-from ..shared import DeviceOcrResult
-from .crop import *
-from .definition import DeviceV1
-
-
-class DeviceV1Ocr:
-    def __init__(self, device: DeviceV1, knn_model: cv2_ml_KNearest):
-        self.__device = device
-        self.__knn_model = knn_model
-
-    @property
-    def device(self):
-        return self.__device
-
-    @device.setter
-    def device(self, value):
-        self.__device = value
-
-    @property
-    def knn_model(self):
-        return self.__knn_model
-
-    @knn_model.setter
-    def knn_model(self, value):
-        self.__knn_model = value
-
-    def preprocess_score_roi(self, __roi_gray: Mat) -> List[Mat]:
-        roi_gray = __roi_gray.copy()
-        contours, _ = cv2.findContours(
-            roi_gray, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE
-        )
-        for contour in contours:
-            rect = cv2.boundingRect(contour)
-            if rect[3] > roi_gray.shape[0] * 0.6:
-                continue
-            roi_gray = cv2.fillPoly(roi_gray, [contour], 0)
-        return roi_gray
-
-    def ocr(self, img_bgr: Mat):
-        rating_class_roi = crop_to_rating_class(img_bgr, self.device)
-        rating_class = ocr_rating_class(rating_class_roi)
-
-        pfl_mr_roi = [
-            crop_to_pure(img_bgr, self.device),
-            crop_to_far(img_bgr, self.device),
-            crop_to_lost(img_bgr, self.device),
-            crop_to_max_recall(img_bgr, self.device),
-        ]
-        pfl_mr_roi = [mask_gray(roi) for roi in pfl_mr_roi]
-
-        pure, far, lost = [
-            ocr_digits_by_contour_knn(roi, self.knn_model) for roi in pfl_mr_roi[:3]
-        ]
-
-        max_recall_contours, _ = cv2.findContours(
-            pfl_mr_roi[3], cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE
-        )
-        max_recall_rects = [cv2.boundingRect(c) for c in max_recall_contours]
-        max_recall_rect = sorted(max_recall_rects, key=lambda r: r[0])[-1]
-        max_recall_roi = crop_xywh(img_bgr, max_recall_rect)
-        max_recall = ocr_digits_by_contour_knn(max_recall_roi, self.knn_model)
-
-        score_roi = crop_to_score(img_bgr, self.device)
-        score_roi = mask_white(score_roi)
-        score_roi = self.preprocess_score_roi(score_roi)
-        score = ocr_digits_by_contour_knn(score_roi, self.knn_model)
-
-        return DeviceOcrResult(
-            song_id=None,
-            title=None,
-            rating_class=rating_class,
-            pure=pure,
-            far=far,
-            lost=lost,
-            score=score,
-            max_recall=max_recall,
-            clear_type=None,
-        )

src/arcaea_offline_ocr/device/v2/__init__.py

@@ -1,4 +0,0 @@
-from .definition import DeviceV2
-from .ocr import DeviceV2Ocr
-from .rois import DeviceV2AutoRois, DeviceV2Rois
-from .shared import MAX_RECALL_CLOSE_KERNEL

src/arcaea_offline_ocr/device/v2/definition.py

@@ -1,26 +0,0 @@
-from typing import Iterable
-
-from attrs import define, field
-
-from ...types import XYWHRect
-
-
-def iterable_to_xywh_rect(__iter: Iterable) -> XYWHRect:
-    return XYWHRect(*__iter)
-
-
-@define(kw_only=True)
-class DeviceV2:
-    version = field(type=int)
-    uuid = field(type=str)
-    name = field(type=str)
-    crop_black_edges = field(type=bool)
-    factor = field(type=float)
-    pure = field(converter=iterable_to_xywh_rect, default=[0, 0, 0, 0])
-    far = field(converter=iterable_to_xywh_rect, default=[0, 0, 0, 0])
-    lost = field(converter=iterable_to_xywh_rect, default=[0, 0, 0, 0])
-    score = field(converter=iterable_to_xywh_rect, default=[0, 0, 0, 0])
-    max_recall_rating_class = field(
-        converter=iterable_to_xywh_rect, default=[0, 0, 0, 0]
-    )
-    title = field(converter=iterable_to_xywh_rect, default=[0, 0, 0, 0])

src/arcaea_offline_ocr/device/v2/ocr.py

@@ -1,172 +0,0 @@
-import math
-from functools import lru_cache
-from typing import Sequence
-
-import cv2
-import numpy as np
-from PIL import Image
-
-from ...crop import crop_xywh
-from ...mask import (
-    mask_byd,
-    mask_ftr,
-    mask_gray,
-    mask_max_recall_purple,
-    mask_pfl_white,
-    mask_prs,
-    mask_pst,
-    mask_white,
-)
-from ...ocr import (
-    FixRects,
-    ocr_digit_samples_knn,
-    ocr_digits_by_contour_knn,
-    preprocess_hog,
-    resize_fill_square,
-)
-from ...phash_db import ImagePHashDatabase
-from ...sift_db import SIFTDatabase
-from ...types import Mat, cv2_ml_KNearest
-from ..shared import DeviceOcrResult
-from .preprocess import find_digits_preprocess
-from .rois import DeviceV2Rois
-from .shared import MAX_RECALL_CLOSE_KERNEL
-from .sizes import SizesV2
-
-
-class DeviceV2Ocr:
-    def __init__(self, knn_model: cv2_ml_KNearest, phash_db: ImagePHashDatabase):
-        self.__knn_model = knn_model
-        self.__phash_db = phash_db
-
-    @property
-    def knn_model(self):
-        if not self.__knn_model:
-            raise ValueError("`knn_model` unset.")
-        return self.__knn_model
-
-    @knn_model.setter
-    def knn_model(self, value: cv2_ml_KNearest):
-        self.__knn_model = value
-
-    @property
-    def phash_db(self):
-        if not self.__phash_db:
-            raise ValueError("`phash_db` unset.")
-        return self.__phash_db
-
-    @phash_db.setter
-    def phash_db(self, value: SIFTDatabase):
-        self.__phash_db = value
-
-    @lru_cache
-    def _get_digit_widths(self, num_list: Sequence[int], factor: float):
-        widths = set()
-        for n in num_list:
-            lower = math.floor(n * factor)
-            upper = math.ceil(n * factor)
-            widths.update(range(lower, upper + 1))
-        return widths
-
-    def _base_ocr_pfl(self, roi_masked: Mat, factor: float = 1.0):
-        contours, _ = cv2.findContours(
-            roi_masked, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE
-        )
-        filtered_contours = [c for c in contours if cv2.contourArea(c) >= 5 * factor]
-        rects = [cv2.boundingRect(c) for c in filtered_contours]
-        rects = FixRects.connect_broken(rects, roi_masked.shape[1], roi_masked.shape[0])
-        rect_contour_map = dict(zip(rects, filtered_contours))
-
-        filtered_rects = [r for r in rects if r[2] >= 5 * factor and r[3] >= 6 * factor]
-        filtered_rects = FixRects.split_connected(roi_masked, filtered_rects)
-        filtered_rects = sorted(filtered_rects, key=lambda r: r[0])
-
-        roi_ocr = roi_masked.copy()
-        filtered_contours_flattened = {tuple(c.flatten()) for c in filtered_contours}
-        for contour in contours:
-            if tuple(contour.flatten()) in filtered_contours_flattened:
-                continue
-            roi_ocr = cv2.fillPoly(roi_ocr, [contour], [0])
-        digit_rois = [
-            resize_fill_square(crop_xywh(roi_ocr, r), 20)
-            for r in sorted(filtered_rects, key=lambda r: r[0])
-        ]
-        # [cv2.imshow(f"r{i}", r) for i, r in enumerate(digit_rois)]
-        # cv2.waitKey(0)
-        samples = preprocess_hog(digit_rois)
-        return ocr_digit_samples_knn(samples, self.knn_model)
-
-    def ocr_song_id(self, rois: DeviceV2Rois):
-        jacket = cv2.cvtColor(rois.jacket, cv2.COLOR_BGR2GRAY)
-        return self.phash_db.lookup_image(Image.fromarray(jacket))[0]
-
-    def ocr_rating_class(self, rois: DeviceV2Rois):
-        roi = cv2.cvtColor(rois.max_recall_rating_class, cv2.COLOR_BGR2HSV)
-        results = [mask_pst(roi), mask_prs(roi), mask_ftr(roi), mask_byd(roi)]
-        return max(enumerate(results), key=lambda i: np.count_nonzero(i[1]))[0]
-
-    def ocr_score(self, rois: DeviceV2Rois):
-        roi = cv2.cvtColor(rois.score, cv2.COLOR_BGR2HSV)
-        roi = mask_white(roi)
-        contours, _ = cv2.findContours(roi, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
-        for contour in contours:
-            x, y, w, h = cv2.boundingRect(contour)
-            if h < roi.shape[0] * 0.6:
-                roi = cv2.fillPoly(roi, [contour], [0])
-        return ocr_digits_by_contour_knn(roi, self.knn_model)
-
-    def mask_pfl(self, pfl_roi: Mat, rois: DeviceV2Rois):
-        return (
-            mask_pfl_white(cv2.cvtColor(pfl_roi, cv2.COLOR_BGR2HSV))
-            if isinstance(rois.sizes, SizesV2)
-            else mask_gray(pfl_roi)
-        )
-
-    def ocr_pure(self, rois: DeviceV2Rois):
-        roi = self.mask_pfl(rois.pure, rois)
-        return self._base_ocr_pfl(roi, rois.sizes.factor)
-
-    def ocr_far(self, rois: DeviceV2Rois):
-        roi = self.mask_pfl(rois.far, rois)
-        return self._base_ocr_pfl(roi, rois.sizes.factor)
-
-    def ocr_lost(self, rois: DeviceV2Rois):
-        roi = self.mask_pfl(rois.lost, rois)
-        return self._base_ocr_pfl(roi, rois.sizes.factor)
-
-    def ocr_max_recall(self, rois: DeviceV2Rois):
-        roi = (
-            mask_max_recall_purple(
-                cv2.cvtColor(rois.max_recall_rating_class, cv2.COLOR_BGR2HSV)
-            )
-            if isinstance(rois.sizes, SizesV2)
-            else mask_gray(rois.max_recall_rating_class)
-        )
-        roi_closed = cv2.morphologyEx(roi, cv2.MORPH_CLOSE, MAX_RECALL_CLOSE_KERNEL)
-        contours, _ = cv2.findContours(
-            roi_closed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE
-        )
-        rects = sorted(
-            [cv2.boundingRect(c) for c in contours], key=lambda r: r[0], reverse=True
-        )
-        max_recall_roi = crop_xywh(roi, rects[0])
-        return ocr_digits_by_contour_knn(max_recall_roi, self.knn_model)
-
-    def ocr(self, rois: DeviceV2Rois):
-        song_id = self.ocr_song_id(rois)
-        rating_class = self.ocr_rating_class(rois)
-        score = self.ocr_score(rois)
-        pure = self.ocr_pure(rois)
-        far = self.ocr_far(rois)
-        lost = self.ocr_lost(rois)
-        max_recall = self.ocr_max_recall(rois)
-
-        return DeviceOcrResult(
-            rating_class=rating_class,
-            pure=pure,
-            far=far,
-            lost=lost,
-            score=score,
-            max_recall=max_recall,
-            song_id=song_id,
-        )

src/arcaea_offline_ocr/device/v2/preprocess.py

@@ -1,54 +0,0 @@
-import cv2
-
-from ...types import Mat
-from .shared import *
-
-
-def find_digits_preprocess(__img_masked: Mat) -> Mat:
-    img = __img_masked.copy()
-    img_denoised = cv2.morphologyEx(img, cv2.MORPH_OPEN, PFL_DENOISE_KERNEL)
-    # img_denoised = cv2.bitwise_and(img, img_denoised)
-
-    denoise_contours, _ = cv2.findContours(
-        img_denoised, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE
-    )
-    # cv2.drawContours(img_denoised, contours, -1, [128], 2)
-
-    # fill all contour.area < max(contour.area) * ratio with black pixels
-    # for denoise purposes
-
-    # define threshold contour area
-    # we assume the smallest digit "1", is 80% height of the image,
-    # and at least 1.5 pixel wide, considering cv2.contourArea always
-    # returns a smaller value than the actual contour area.
-    max_contour_area = __img_masked.shape[0] * 0.8 * 1.5
-    filtered_contours = list(
-        filter(lambda c: cv2.contourArea(c) >= max_contour_area, denoise_contours)
-    )
-
-    filtered_contours_flattened = {tuple(c.flatten()) for c in filtered_contours}
-
-    for contour in denoise_contours:
-        if tuple(contour.flatten()) not in filtered_contours_flattened:
-            img_denoised = cv2.fillPoly(img_denoised, [contour], [0])
-
-    # old algorithm, finding the largest contour area
-    ## contour_area_tuples = [(contour, cv2.contourArea(contour)) for contour in contours]
-    ## contour_area_tuples = sorted(
-    ##     contour_area_tuples, key=lambda item: item[1], reverse=True
-    ## )
-    ## max_contour_area = contour_area_tuples[0][1]
-    ## print(max_contour_area, [item[1] for item in contour_area_tuples])
-    ## contours_filter_end_index = len(contours)
-    ## for i, item in enumerate(contour_area_tuples):
-    ##     contour, area = item
-    ##     if area < max_contour_area * 0.15:
-    ##         contours_filter_end_index = i
-    ##         break
-    ## contours = [item[0] for item in contour_area_tuples]
-    ## for contour in contours[-contours_filter_end_index - 1:]:
-    ##     img = cv2.fillPoly(img, [contour], [0])
-    ##     img_denoised = cv2.fillPoly(img_denoised, [contour], [0])
-    ## contours = contours[:contours_filter_end_index]
-
-    return img_denoised

src/arcaea_offline_ocr/device/v2/rois.py

@@ -1,199 +0,0 @@
-from typing import Union
-
-from ...crop import crop_black_edges, crop_xywh
-from ...types import Mat, XYWHRect
-from .definition import DeviceV2
-from .sizes import Sizes, SizesV1
-
-
-def to_int(num: Union[int, float]) -> int:
-    return round(num)
-
-
-class DeviceV2Rois:
-    def __init__(self, device: DeviceV2, img: Mat):
-        self.device = device
-        self.sizes = SizesV1(self.device.factor)
-        self.__img = img
-
-    @staticmethod
-    def construct_int_xywh_rect(x, y, w, h) -> XYWHRect:
-        return XYWHRect(*[to_int(item) for item in [x, y, w, h]])
-
-    @property
-    def img(self):
-        return self.__img
-
-    @img.setter
-    def img(self, img: Mat):
-        self.__img = (
-            crop_black_edges(img) if self.device.crop_black_edges else img.copy()
-        )
-
-    @property
-    def h(self):
-        return self.img.shape[0]
-
-    @property
-    def vmid(self):
-        return self.h / 2
-
-    @property
-    def w(self):
-        return self.img.shape[1]
-
-    @property
-    def hmid(self):
-        return self.w / 2
-
-    @property
-    def h_without_top_bar(self):
-        """img_height -= top_bar_height"""
-        return self.h - self.sizes.TOP_BAR_HEIGHT
-
-    @property
-    def h_without_top_bar_mid(self):
-        return self.sizes.TOP_BAR_HEIGHT + self.h_without_top_bar / 2
-
-    @property
-    def pfl_top(self):
-        return self.h_without_top_bar_mid + self.sizes.PFL_TOP_FROM_VMID
-
-    @property
-    def pfl_left(self):
-        return self.hmid + self.sizes.PFL_LEFT_FROM_HMID
-
-    @property
-    def pure_rect(self):
-        return self.construct_int_xywh_rect(
-            x=self.pfl_left,
-            y=self.pfl_top,
-            w=self.sizes.PFL_WIDTH,
-            h=self.sizes.PFL_FONT_PX,
-        )
-
-    @property
-    def pure(self):
-        return crop_xywh(self.img, self.pure_rect)
-
-    @property
-    def far_rect(self):
-        return self.construct_int_xywh_rect(
-            x=self.pfl_left,
-            y=self.pfl_top + self.sizes.PFL_FONT_PX + self.sizes.PURE_FAR_GAP,
-            w=self.sizes.PFL_WIDTH,
-            h=self.sizes.PFL_FONT_PX,
-        )
-
-    @property
-    def far(self):
-        return crop_xywh(self.img, self.far_rect)
-
-    @property
-    def lost_rect(self):
-        return self.construct_int_xywh_rect(
-            x=self.pfl_left,
-            y=(
-                self.pfl_top
-                + self.sizes.PFL_FONT_PX * 2
-                + self.sizes.PURE_FAR_GAP
-                + self.sizes.FAR_LOST_GAP
-            ),
-            w=self.sizes.PFL_WIDTH,
-            h=self.sizes.PFL_FONT_PX,
-        )
-
-    @property
-    def lost(self):
-        return crop_xywh(self.img, self.lost_rect)
-
-    @property
-    def score_rect(self):
-        return self.construct_int_xywh_rect(
-            x=self.hmid - (self.sizes.SCORE_WIDTH / 2),
-            y=(
-                self.h_without_top_bar_mid
-                + self.sizes.SCORE_BOTTOM_FROM_VMID
-                - self.sizes.SCORE_FONT_PX
-            ),
-            w=self.sizes.SCORE_WIDTH,
-            h=self.sizes.SCORE_FONT_PX,
-        )
-
-    @property
-    def score(self):
-        return crop_xywh(self.img, self.score_rect)
-
-    @property
-    def max_recall_rating_class_rect(self):
-        x = (
-            self.hmid
-            + self.sizes.JACKET_RIGHT_FROM_HOR_MID
-            - self.sizes.JACKET_WIDTH
-            - 25 * self.sizes.factor
-        )
-        return self.construct_int_xywh_rect(
-            x=x,
-            y=(
-                self.h_without_top_bar_mid
-                - self.sizes.SCORE_PANEL[1] / 2
-                - self.sizes.MR_RT_HEIGHT
-            ),
-            w=self.sizes.MR_RT_WIDTH,
-            h=self.sizes.MR_RT_HEIGHT,
-        )
-
-    @property
-    def max_recall_rating_class(self):
-        return crop_xywh(self.img, self.max_recall_rating_class_rect)
-
-    @property
-    def title_rect(self):
-        return self.construct_int_xywh_rect(
-            x=0,
-            y=self.h_without_top_bar_mid
-            + self.sizes.TITLE_BOTTOM_FROM_VMID
-            - self.sizes.TITLE_FONT_PX,
-            w=self.hmid + self.sizes.TITLE_WIDTH_RIGHT,
-            h=self.sizes.TITLE_FONT_PX,
-        )
-
-    @property
-    def title(self):
-        return crop_xywh(self.img, self.title_rect)
-
-    @property
-    def jacket_rect(self):
-        return self.construct_int_xywh_rect(
-            x=self.hmid
-            + self.sizes.JACKET_RIGHT_FROM_HOR_MID
-            - self.sizes.JACKET_WIDTH,
-            y=self.h_without_top_bar_mid - self.sizes.SCORE_PANEL[1] / 2,
-            w=self.sizes.JACKET_WIDTH,
-            h=self.sizes.JACKET_WIDTH,
-        )
-
-    @property
-    def jacket(self):
-        return crop_xywh(self.img, self.jacket_rect)
-
-
-class DeviceV2AutoRois(DeviceV2Rois):
-    @staticmethod
-    def get_factor(width: int, height: int):
-        ratio = width / height
-        return ((width / 16) * 9) / 720 if ratio < (16 / 9) else height / 720
-
-    def __init__(self, img: Mat):
-        factor = self.get_factor(img.shape[1], img.shape[0])
-        self.sizes = SizesV1(factor)
-        self.__img = None
-        self.img = img
-
-    @property
-    def img(self):
-        return self.__img
-
-    @img.setter
-    def img(self, img: Mat):
-        self.__img = crop_black_edges(img)

src/arcaea_offline_ocr/device/v2/shared.py

@@ -1,9 +0,0 @@
-from cv2 import MORPH_RECT, getStructuringElement
-
-PFL_DENOISE_KERNEL = getStructuringElement(MORPH_RECT, [2, 2])
-PFL_ERODE_KERNEL = getStructuringElement(MORPH_RECT, [3, 3])
-PFL_CLOSE_HORIZONTAL_KERNEL = getStructuringElement(MORPH_RECT, [10, 1])
-
-MAX_RECALL_DENOISE_KERNEL = getStructuringElement(MORPH_RECT, [3, 3])
-MAX_RECALL_ERODE_KERNEL = getStructuringElement(MORPH_RECT, [2, 2])
-MAX_RECALL_CLOSE_KERNEL = getStructuringElement(MORPH_RECT, [20, 1])

src/arcaea_offline_ocr/device/v2/sizes.py

@@ -1,254 +0,0 @@
-from typing import Tuple, Union
-
-
-def apply_factor(num: Union[int, float], factor: float):
-    return num * factor
-
-
-class Sizes:
-    def __init__(self, factor: float):
-        raise NotImplementedError()
-
-    @property
-    def TOP_BAR_HEIGHT(self):
-        ...
-
-    @property
-    def SCORE_PANEL(self) -> Tuple[int, int]:
-        ...
-
-    @property
-    def PFL_TOP_FROM_VMID(self):
-        ...
-
-    @property
-    def PFL_LEFT_FROM_HMID(self):
-        ...
-
-    @property
-    def PFL_WIDTH(self):
-        ...
-
-    @property
-    def PFL_FONT_PX(self):
-        ...
-
-    @property
-    def PURE_FAR_GAP(self):
-        ...
-
-    @property
-    def FAR_LOST_GAP(self):
-        ...
-
-    @property
-    def SCORE_BOTTOM_FROM_VMID(self):
-        ...
-
-    @property
-    def SCORE_FONT_PX(self):
-        ...
-
-    @property
-    def SCORE_WIDTH(self):
-        ...
-
-    @property
-    def JACKET_RIGHT_FROM_HOR_MID(self):
-        ...
-
-    @property
-    def JACKET_WIDTH(self):
-        ...
-
-    @property
-    def MR_RT_RIGHT_FROM_HMID(self):
-        ...
-
-    @property
-    def MR_RT_WIDTH(self):
-        ...
-
-    @property
-    def MR_RT_HEIGHT(self):
-        ...
-
-    @property
-    def TITLE_BOTTOM_FROM_VMID(self):
-        ...
-
-    @property
-    def TITLE_FONT_PX(self):
-        ...
-
-    @property
-    def TITLE_WIDTH_RIGHT(self):
-        ...
-
-
-class SizesV1(Sizes):
-    def __init__(self, factor: float):
-        self.factor = factor
-
-    def apply_factor(self, num):
-        return apply_factor(num, self.factor)
-
-    @property
-    def TOP_BAR_HEIGHT(self):
-        return self.apply_factor(50)
-
-    @property
-    def SCORE_PANEL(self) -> Tuple[int, int]:
-        return tuple(self.apply_factor(num) for num in [485, 239])
-
-    @property
-    def PFL_TOP_FROM_VMID(self):
-        return self.apply_factor(135)
-
-    @property
-    def PFL_LEFT_FROM_HMID(self):
-        return self.apply_factor(5)
-
-    @property
-    def PFL_WIDTH(self):
-        return self.apply_factor(76)
-
-    @property
-    def PFL_FONT_PX(self):
-        return self.apply_factor(26)
-
-    @property
-    def PURE_FAR_GAP(self):
-        return self.apply_factor(12)
-
-    @property
-    def FAR_LOST_GAP(self):
-        return self.apply_factor(10)
-
-    @property
-    def SCORE_BOTTOM_FROM_VMID(self):
-        return self.apply_factor(-50)
-
-    @property
-    def SCORE_FONT_PX(self):
-        return self.apply_factor(45)
-
-    @property
-    def SCORE_WIDTH(self):
-        return self.apply_factor(280)
-
-    @property
-    def JACKET_RIGHT_FROM_HOR_MID(self):
-        return self.apply_factor(-235)
-
-    @property
-    def JACKET_WIDTH(self):
-        return self.apply_factor(375)
-
-    @property
-    def MR_RT_RIGHT_FROM_HMID(self):
-        return self.apply_factor(-300)
-
-    @property
-    def MR_RT_WIDTH(self):
-        return self.apply_factor(275)
-
-    @property
-    def MR_RT_HEIGHT(self):
-        return self.apply_factor(75)
-
-    @property
-    def TITLE_BOTTOM_FROM_VMID(self):
-        return self.apply_factor(-265)
-
-    @property
-    def TITLE_FONT_PX(self):
-        return self.apply_factor(40)
-
-    @property
-    def TITLE_WIDTH_RIGHT(self):
-        return self.apply_factor(275)
-
-
-class SizesV2(Sizes):
-    def __init__(self, factor: float):
-        self.factor = factor
-
-    def apply_factor(self, num):
-        return apply_factor(num, self.factor)
-
-    @property
-    def TOP_BAR_HEIGHT(self):
-        return self.apply_factor(50)
-
-    @property
-    def SCORE_PANEL(self) -> Tuple[int, int]:
-        return tuple(self.apply_factor(num) for num in [447, 233])
-
-    @property
-    def PFL_TOP_FROM_VMID(self):
-        return self.apply_factor(142)
-
-    @property
-    def PFL_LEFT_FROM_HMID(self):
-        return self.apply_factor(10)
-
-    @property
-    def PFL_WIDTH(self):
-        return self.apply_factor(60)
-
-    @property
-    def PFL_FONT_PX(self):
-        return self.apply_factor(16)
-
-    @property
-    def PURE_FAR_GAP(self):
-        return self.apply_factor(20)
-
-    @property
-    def FAR_LOST_GAP(self):
-        return self.apply_factor(23)
-
-    @property
-    def SCORE_BOTTOM_FROM_VMID(self):
-        return self.apply_factor(-50)
-
-    @property
-    def SCORE_FONT_PX(self):
-        return self.apply_factor(45)
-
-    @property
-    def SCORE_WIDTH(self):
-        return self.apply_factor(280)
-
-    @property
-    def JACKET_RIGHT_FROM_HOR_MID(self):
-        return self.apply_factor(-235)
-
-    @property
-    def JACKET_WIDTH(self):
-        return self.apply_factor(375)
-
-    @property
-    def MR_RT_RIGHT_FROM_HMID(self):
-        return self.apply_factor(-330)
-
-    @property
-    def MR_RT_WIDTH(self):
-        return self.apply_factor(330)
-
-    @property
-    def MR_RT_HEIGHT(self):
-        return self.apply_factor(75)
-
-    @property
-    def TITLE_BOTTOM_FROM_VMID(self):
-        return self.apply_factor(-265)
-
-    @property
-    def TITLE_FONT_PX(self):
-        return self.apply_factor(40)
-
-    @property
-    def TITLE_WIDTH_RIGHT(self):
-        return self.apply_factor(275)

src/arcaea_offline_ocr/extractor/__init__.py

@@ -1,2 +0,0 @@
-from .common import Extractor
-from .sizes import *

src/arcaea_offline_ocr/extractor/common.py

@@ -1,45 +0,0 @@
-import cv2
-
-from ..crop import crop_xywh
-from .sizes.common import Sizes
-
-
-class Extractor:
-    def __init__(self, img: cv2.Mat, sizes: Sizes):
-        self.img = img
-        self.sizes = sizes
-
-    def __construct_int_rect(self, rect):
-        return tuple(round(r) for r in rect)
-
-    @property
-    def pure(self):
-        return crop_xywh(self.img, self.__construct_int_rect(self.sizes.pure))
-
-    @property
-    def far(self):
-        return crop_xywh(self.img, self.__construct_int_rect(self.sizes.far))
-
-    @property
-    def lost(self):
-        return crop_xywh(self.img, self.__construct_int_rect(self.sizes.lost))
-
-    @property
-    def score(self):
-        return crop_xywh(self.img, self.__construct_int_rect(self.sizes.score))
-
-    @property
-    def rating_class(self):
-        return crop_xywh(self.img, self.__construct_int_rect(self.sizes.rating_class))
-
-    @property
-    def max_recall(self):
-        return crop_xywh(self.img, self.__construct_int_rect(self.sizes.max_recall))
-
-    @property
-    def clear_status(self):
-        return crop_xywh(self.img, self.__construct_int_rect(self.sizes.clear_status))
-
-    @property
-    def partner_icon(self):
-        return crop_xywh(self.img, self.__construct_int_rect(self.sizes.partner_icon))

src/arcaea_offline_ocr/extractor/sizes/__init__.py

@@ -1 +0,0 @@
-from .auto import *

src/arcaea_offline_ocr/extractor/sizes/auto/__init__.py

@@ -1,3 +0,0 @@
-from .common import AutoSizes
-from .t1 import AutoSizesT1
-from .t2 import AutoSizesT2

src/arcaea_offline_ocr/extractor/sizes/auto/common.py

@@ -1,7 +0,0 @@
-from ..common import Sizes
-
-
-class AutoSizes(Sizes):
-    def __init__(self, w: int, h: int):
-        self.w = w
-        self.h = h

src/arcaea_offline_ocr/extractor/sizes/auto/t1.py

@@ -1,123 +0,0 @@
-from .common import AutoSizes
-
-
-class AutoSizesT1(AutoSizes):
-    @property
-    def factor(self):
-        return (
-            ((self.w / 16) * 9) / 720 if (self.w / self.h) < (16 / 9) else self.h / 720
-        )
-
-    @property
-    def w_mid(self):
-        return self.w / 2
-
-    @property
-    def h_mid(self):
-        return self.h / 2
-
-    @property
-    def top_bar(self):
-        return (0, 0, self.w, 50 * self.factor)
-
-    @property
-    def layout_area_h_mid(self):
-        return self.h / 2 + self.top_bar[3]
-
-    @property
-    def pfl_left_from_w_mid(self):
-        return 5 * self.factor
-
-    @property
-    def pfl_x(self):
-        return self.w_mid + self.pfl_left_from_w_mid
-
-    @property
-    def pfl_w(self):
-        return 76 * self.factor
-
-    @property
-    def pfl_h(self):
-        return 26 * self.factor
-
-    @property
-    def pure(self):
-        return (
-            self.pfl_x,
-            self.layout_area_h_mid + 110 * self.factor,
-            self.pfl_w,
-            self.pfl_h,
-        )
-
-    @property
-    def far(self):
-        return (
-            self.pfl_x,
-            self.pure[1] + self.pure[3] + 12 * self.factor,
-            self.pfl_w,
-            self.pfl_h,
-        )
-
-    @property
-    def lost(self):
-        return (
-            self.pfl_x,
-            self.far[1] + self.far[3] + 10 * self.factor,
-            self.pfl_w,
-            self.pfl_h,
-        )
-
-    @property
-    def score(self):
-        w = 280 * self.factor
-        h = 45 * self.factor
-        return (
-            self.w_mid - w / 2,
-            self.layout_area_h_mid - 75 * self.factor - h,
-            w,
-            h,
-        )
-
-    @property
-    def rating_class(self):
-        return (
-            self.w_mid - 610 * self.factor,
-            self.layout_area_h_mid - 180 * self.factor,
-            265 * self.factor,
-            35 * self.factor,
-        )
-
-    @property
-    def max_recall(self):
-        return (
-            self.w_mid - 465 * self.factor,
-            self.layout_area_h_mid - 215 * self.factor,
-            150 * self.factor,
-            35 * self.factor,
-        )
-
-    @property
-    def jacket(self):
-        return (
-            self.w_mid - 610 * self.factor,
-            self.layout_area_h_mid - 143 * self.factor,
-            375 * self.factor,
-            375 * self.factor,
-        )
-
-    @property
-    def clear_status(self):
-        w = 550 * self.factor
-        h = 60 * self.factor
-        return (
-            self.w_mid - w / 2,
-            self.layout_area_h_mid - 155 * self.factor - h,
-            w,
-            h,
-        )
-
-    @property
-    def partner_icon(self):
-        w = 90 * self.factor
-        h = 75 * self.factor
-        return (self.w_mid - w / 2, 0, w, h)

src/arcaea_offline_ocr/extractor/sizes/auto/t2.py

@@ -1,125 +0,0 @@
-from .common import AutoSizes
-
-
-class AutoSizesT2(AutoSizes):
-    @property
-    def factor(self):
-        return (
-            ((self.w / 16) * 9) / 1080
-            if (self.w / self.h) < (16 / 9)
-            else self.h / 1080
-        )
-
-    @property
-    def w_mid(self):
-        return self.w / 2
-
-    @property
-    def h_mid(self):
-        return self.h / 2
-
-    @property
-    def top_bar(self):
-        return (0, 0, self.w, 75 * self.factor)
-
-    @property
-    def layout_area_h_mid(self):
-        return self.h / 2 + self.top_bar[3]
-
-    @property
-    def pfl_mid_from_w_mid(self):
-        return 60 * self.factor
-
-    @property
-    def pfl_x(self):
-        return self.w_mid + 10 * self.factor
-
-    @property
-    def pfl_w(self):
-        return 100 * self.factor
-
-    @property
-    def pfl_h(self):
-        return 24 * self.factor
-
-    @property
-    def pure(self):
-        return (
-            self.pfl_x,
-            self.layout_area_h_mid + 175 * self.factor,
-            self.pfl_w,
-            self.pfl_h,
-        )
-
-    @property
-    def far(self):
-        return (
-            self.pfl_x,
-            self.pure[1] + self.pure[3] + 30 * self.factor,
-            self.pfl_w,
-            self.pfl_h,
-        )
-
-    @property
-    def lost(self):
-        return (
-            self.pfl_x,
-            self.far[1] + self.far[3] + 35 * self.factor,
-            self.pfl_w,
-            self.pfl_h,
-        )
-
-    @property
-    def score(self):
-        w = 420 * self.factor
-        h = 70 * self.factor
-        return (
-            self.w_mid - w / 2,
-            self.layout_area_h_mid - 110 * self.factor - h,
-            w,
-            h,
-        )
-
-    @property
-    def rating_class(self):
-        return (
-            max(0, self.w_mid - 965 * self.factor),
-            self.layout_area_h_mid - 330 * self.factor,
-            350 * self.factor,
-            110 * self.factor,
-        )
-
-    @property
-    def max_recall(self):
-        return (
-            self.w_mid - 625 * self.factor,
-            self.layout_area_h_mid - 275 * self.factor,
-            150 * self.factor,
-            50 * self.factor,
-        )
-
-    @property
-    def jacket(self):
-        return (
-            self.w_mid - 915 * self.factor,
-            self.layout_area_h_mid - 215 * self.factor,
-            565 * self.factor,
-            565 * self.factor,
-        )
-
-    @property
-    def clear_status(self):
-        w = 825 * self.factor
-        h = 90 * self.factor
-        return (
-            self.w_mid - w / 2,
-            self.layout_area_h_mid - 235 * self.factor - h,
-            w,
-            h,
-        )
-
-    @property
-    def partner_icon(self):
-        w = 135 * self.factor
-        h = 110 * self.factor
-        return (self.w_mid - w / 2, 0, w, h)

src/arcaea_offline_ocr/extractor/sizes/common.py

@@ -1,15 +0,0 @@
-from typing import Tuple
-
-Rect = Tuple[int, int, int, int]
-
-
-class Sizes:
-    pure: Rect
-    far: Rect
-    lost: Rect
-    score: Rect
-    rating_class: Rect
-    max_recall: Rect
-    jacket: Rect
-    clear_status: Rect
-    partner_icon: Rect

src/arcaea_offline_ocr/mask.py

@@ -1,119 +0,0 @@
-import cv2
-import numpy as np
-
-from .types import Mat
-
-__all__ = [
-    "GRAY_MIN_HSV",
-    "GRAY_MAX_HSV",
-    "WHITE_MIN_HSV",
-    "WHITE_MAX_HSV",
-    "PFL_WHITE_MIN_HSV",
-    "PFL_WHITE_MAX_HSV",
-    "PST_MIN_HSV",
-    "PST_MAX_HSV",
-    "PRS_MIN_HSV",
-    "PRS_MAX_HSV",
-    "FTR_MIN_HSV",
-    "FTR_MAX_HSV",
-    "BYD_MIN_HSV",
-    "BYD_MAX_HSV",
-    "MAX_RECALL_PURPLE_MIN_HSV",
-    "MAX_RECALL_PURPLE_MAX_HSV",
-    "mask_gray",
-    "mask_white",
-    "mask_pfl_white",
-    "mask_pst",
-    "mask_prs",
-    "mask_ftr",
-    "mask_byd",
-    "mask_rating_class",
-    "mask_max_recall_purple",
-]
-
-GRAY_MIN_HSV = np.array([0, 0, 70], np.uint8)
-GRAY_MAX_HSV = np.array([0, 0, 200], np.uint8)
-
-GRAY_MIN_BGR = np.array([50] * 3, np.uint8)
-GRAY_MAX_BGR = np.array([160] * 3, np.uint8)
-
-WHITE_MIN_HSV = np.array([0, 0, 240], np.uint8)
-WHITE_MAX_HSV = np.array([179, 10, 255], np.uint8)
-
-PFL_WHITE_MIN_HSV = np.array([0, 0, 248], np.uint8)
-PFL_WHITE_MAX_HSV = np.array([179, 10, 255], np.uint8)
-
-PST_MIN_HSV = np.array([100, 50, 80], np.uint8)
-PST_MAX_HSV = np.array([100, 255, 255], np.uint8)
-
-PRS_MIN_HSV = np.array([43, 40, 75], np.uint8)
-PRS_MAX_HSV = np.array([50, 155, 190], np.uint8)
-
-FTR_MIN_HSV = np.array([149, 30, 0], np.uint8)
-FTR_MAX_HSV = np.array([155, 181, 150], np.uint8)
-
-BYD_MIN_HSV = np.array([170, 50, 50], np.uint8)
-BYD_MAX_HSV = np.array([179, 210, 198], np.uint8)
-
-MAX_RECALL_PURPLE_MIN_HSV = np.array([125, 0, 0], np.uint8)
-MAX_RECALL_PURPLE_MAX_HSV = np.array([130, 100, 150], np.uint8)
-
-
-def mask_gray(__img_bgr: Mat):
-    # bgr_value_equal_mask = all(__img_bgr[:, 1:] == __img_bgr[:, :-1], axis=1)
-    bgr_value_equal_mask = np.max(__img_bgr, axis=2) - np.min(__img_bgr, axis=2) <= 5
-    img_bgr = __img_bgr.copy()
-    img_bgr[~bgr_value_equal_mask] = np.array([0, 0, 0], __img_bgr.dtype)
-    img_bgr = cv2.erode(img_bgr, cv2.getStructuringElement(cv2.MORPH_RECT, (2, 2)))
-    img_bgr = cv2.dilate(img_bgr, cv2.getStructuringElement(cv2.MORPH_RECT, (1, 1)))
-    return cv2.inRange(img_bgr, GRAY_MIN_BGR, GRAY_MAX_BGR)
-
-
-def mask_white(img_hsv: Mat):
-    mask = cv2.inRange(img_hsv, WHITE_MIN_HSV, WHITE_MAX_HSV)
-    mask = cv2.dilate(mask, cv2.getStructuringElement(cv2.MORPH_RECT, (2, 2)))
-    return mask
-
-
-def mask_pfl_white(img_hsv: Mat):
-    mask = cv2.inRange(img_hsv, PFL_WHITE_MIN_HSV, PFL_WHITE_MAX_HSV)
-    mask = cv2.dilate(mask, cv2.getStructuringElement(cv2.MORPH_RECT, (2, 2)))
-    return mask
-
-
-def mask_pst(img_hsv: Mat):
-    mask = cv2.inRange(img_hsv, PST_MIN_HSV, PST_MAX_HSV)
-    mask = cv2.dilate(mask, (1, 1))
-    return mask
-
-
-def mask_prs(img_hsv: Mat):
-    mask = cv2.inRange(img_hsv, PRS_MIN_HSV, PRS_MAX_HSV)
-    mask = cv2.dilate(mask, (1, 1))
-    return mask
-
-
-def mask_ftr(img_hsv: Mat):
-    mask = cv2.inRange(img_hsv, FTR_MIN_HSV, FTR_MAX_HSV)
-    mask = cv2.dilate(mask, (1, 1))
-    return mask
-
-
-def mask_byd(img_hsv: Mat):
-    mask = cv2.inRange(img_hsv, BYD_MIN_HSV, BYD_MAX_HSV)
-    mask = cv2.dilate(mask, (2, 2))
-    return mask
-
-
-def mask_rating_class(img_hsv: Mat):
-    pst = mask_pst(img_hsv)
-    prs = mask_prs(img_hsv)
-    ftr = mask_ftr(img_hsv)
-    byd = mask_byd(img_hsv)
-    return cv2.bitwise_or(byd, cv2.bitwise_or(ftr, cv2.bitwise_or(pst, prs)))
-
-
-def mask_max_recall_purple(img_hsv: Mat):
-    mask = cv2.inRange(img_hsv, MAX_RECALL_PURPLE_MIN_HSV, MAX_RECALL_PURPLE_MAX_HSV)
-    mask = cv2.dilate(mask, (2, 2))
-    return mask

src/arcaea_offline_ocr/masker/common.py

@@ -1,55 +0,0 @@
-import cv2
-
-
-class Masker:
-    @staticmethod
-    def pure(roi_bgr: cv2.Mat) -> cv2.Mat:
-        raise NotImplementedError()
-
-    @staticmethod
-    def far(roi_bgr: cv2.Mat) -> cv2.Mat:
-        raise NotImplementedError()
-
-    @staticmethod
-    def lost(roi_bgr: cv2.Mat) -> cv2.Mat:
-        raise NotImplementedError()
-
-    @staticmethod
-    def score(roi_bgr: cv2.Mat) -> cv2.Mat:
-        raise NotImplementedError()
-
-    @staticmethod
-    def rating_class_pst(roi_bgr: cv2.Mat) -> cv2.Mat:
-        raise NotImplementedError()
-
-    @staticmethod
-    def rating_class_prs(roi_bgr: cv2.Mat) -> cv2.Mat:
-        raise NotImplementedError()
-
-    @staticmethod
-    def rating_class_ftr(roi_bgr: cv2.Mat) -> cv2.Mat:
-        raise NotImplementedError()
-
-    @staticmethod
-    def rating_class_byd(roi_bgr: cv2.Mat) -> cv2.Mat:
-        raise NotImplementedError()
-
-    @staticmethod
-    def max_recall(roi_bgr: cv2.Mat) -> cv2.Mat:
-        raise NotImplementedError()
-
-    @staticmethod
-    def clear_status_track_lost(roi_bgr: cv2.Mat) -> cv2.Mat:
-        raise NotImplementedError()
-
-    @staticmethod
-    def clear_status_track_complete(roi_bgr: cv2.Mat) -> cv2.Mat:
-        raise NotImplementedError()
-
-    @staticmethod
-    def clear_status_full_recall(roi_bgr: cv2.Mat) -> cv2.Mat:
-        raise NotImplementedError()
-
-    @staticmethod
-    def clear_status_pure_memory(roi_bgr: cv2.Mat) -> cv2.Mat:
-        raise NotImplementedError()

src/arcaea_offline_ocr/ocr.py

@@ -1,211 +0,0 @@
-import math
-from copy import deepcopy
-from typing import Optional, Sequence, Tuple
-
-import cv2
-import numpy as np
-from numpy.linalg import norm
-
-from .crop import crop_xywh
-from .mask import mask_byd, mask_ftr, mask_prs, mask_pst
-from .types import Mat, cv2_ml_KNearest
-
-__all__ = [
-    "FixRects",
-    "preprocess_hog",
-    "ocr_digits_by_contour_get_samples",
-    "ocr_digits_by_contour_knn",
-]
-
-
-class FixRects:
-    @staticmethod
-    def connect_broken(
-        rects: Sequence[Tuple[int, int, int, int]],
-        img_width: int,
-        img_height: int,
-        tolerance: Optional[int] = None,
-    ):
-        # for a "broken" digit, please refer to
-        # /assets/fix_rects/broken_masked.jpg
-        # the larger "5" in the image is a "broken" digit
-
-        if tolerance is None:
-            tolerance = math.ceil(img_width * 0.08)
-
-        new_rects = []
-        consumed_rects = []
-        for rect in rects:
-            if rect in consumed_rects:
-                continue
-
-            x, y, w, h = rect
-            # grab those small rects
-            if not img_height * 0.1 <= h <= img_height * 0.6:
-                continue
-
-            group = []
-            # see if there's other rects that have near left & right borders
-            for other_rect in rects:
-                if rect == other_rect:
-                    continue
-                ox, oy, ow, oh = other_rect
-                if abs(x - ox) < tolerance and abs((x + w) - (ox + ow)) < tolerance:
-                    group.append(other_rect)
-
-            if group:
-                group.append(rect)
-                consumed_rects.extend(group)
-                # calculate the new rect
-                new_x = min(r[0] for r in group)
-                new_y = min(r[1] for r in group)
-                new_right = max(r[0] + r[2] for r in group)
-                new_bottom = max(r[1] + r[3] for r in group)
-                new_w = new_right - new_x
-                new_h = new_bottom - new_y
-                new_rects.append((new_x, new_y, new_w, new_h))
-
-        return_rects = deepcopy(rects)
-        return_rects = [r for r in return_rects if r not in consumed_rects]
-        return_rects.extend(new_rects)
-        return return_rects
-
-    @staticmethod
-    def split_connected(
-        img_masked: Mat,
-        rects: Sequence[Tuple[int, int, int, int]],
-        rect_wh_ratio: float = 1.05,
-        width_range_ratio: float = 0.1,
-    ):
-        connected_rects = []
-        new_rects = []
-        for rect in rects:
-            rx, ry, rw, rh = rect
-            if rw / rh > rect_wh_ratio:
-                # consider this is a connected contour
-                connected_rects.append(rect)
-
-                # find the thinnest part
-                border_ignore = round(rw * width_range_ratio)
-                img_cropped = crop_xywh(
-                    img_masked,
-                    (border_ignore, ry, rw - border_ignore, rh),
-                )
-                white_pixels = {}  # dict[x, white_pixel_number]
-                for i in range(img_cropped.shape[1]):
-                    col = img_cropped[:, i]
-                    white_pixels[rx + border_ignore + i] = np.count_nonzero(col > 200)
-                least_white_pixels = min(v for v in white_pixels.values() if v > 0)
-                x_values = [
-                    x
-                    for x, pixel in white_pixels.items()
-                    if pixel == least_white_pixels
-                ]
-                # select only middle values
-                x_mean = np.mean(x_values)
-                x_std = np.std(x_values)
-                x_values = [
-                    x
-                    for x in x_values
-                    if x_mean - x_std * 1.5 <= x <= x_mean + x_std * 1.5
-                ]
-                x_mid = round(np.median(x_values))
-
-                # split the rect
-                new_rects.extend(
-                    [(rx, ry, x_mid - rx, rh), (x_mid, ry, rx + rw - x_mid, rh)]
-                )
-
-        return_rects = deepcopy(rects)
-        return_rects = [r for r in rects if r not in connected_rects]
-        return_rects.extend(new_rects)
-        return return_rects
-
-
-def resize_fill_square(img: Mat, target: int = 20):
-    h, w = img.shape[:2]
-    if h > w:
-        new_h = target
-        new_w = round(w * (target / h))
-    else:
-        new_w = target
-        new_h = round(h * (target / w))
-    resized = cv2.resize(img, (new_w, new_h))
-
-    border_size = math.ceil((max(new_w, new_h) - min(new_w, new_h)) / 2)
-    if new_w < new_h:
-        resized = cv2.copyMakeBorder(
-            resized, 0, 0, border_size, border_size, cv2.BORDER_CONSTANT
-        )
-    else:
-        resized = cv2.copyMakeBorder(
-            resized, border_size, border_size, 0, 0, cv2.BORDER_CONSTANT
-        )
-    return cv2.resize(resized, (target, target))
-
-
-def preprocess_hog(digit_rois):
-    # https://github.com/opencv/opencv/blob/f834736307c8328340aea48908484052170c9224/samples/python/digits.py
-    samples = []
-    for digit in digit_rois:
-        gx = cv2.Sobel(digit, cv2.CV_32F, 1, 0)
-        gy = cv2.Sobel(digit, cv2.CV_32F, 0, 1)
-        mag, ang = cv2.cartToPolar(gx, gy)
-        bin_n = 16
-        _bin = np.int32(bin_n * ang / (2 * np.pi))
-        bin_cells = _bin[:10, :10], _bin[10:, :10], _bin[:10, 10:], _bin[10:, 10:]
-        mag_cells = mag[:10, :10], mag[10:, :10], mag[:10, 10:], mag[10:, 10:]
-        hists = [
-            np.bincount(b.ravel(), m.ravel(), bin_n)
-            for b, m in zip(bin_cells, mag_cells)
-        ]
-        hist = np.hstack(hists)
-
-        # transform to Hellinger kernel
-        eps = 1e-7
-        hist /= hist.sum() + eps
-        hist = np.sqrt(hist)
-        hist /= norm(hist) + eps
-
-        samples.append(hist)
-    return np.float32(samples)
-
-
-def ocr_digit_samples_knn(__samples, knn_model: cv2_ml_KNearest, k: int = 4):
-    _, results, _, _ = knn_model.findNearest(__samples, k)
-    result_list = [int(r) for r in results.ravel()]
-    result_str = "".join(str(r) for r in result_list if r > -1)
-    return int(result_str) if result_str else 0
-
-
-def ocr_digits_by_contour_get_samples(__roi_gray: Mat, size: int):
-    roi = __roi_gray.copy()
-    contours, _ = cv2.findContours(roi, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
-    rects = [cv2.boundingRect(c) for c in contours]
-    rects = FixRects.connect_broken(rects, roi.shape[1], roi.shape[0])
-    rects = FixRects.split_connected(roi, rects)
-    rects = sorted(rects, key=lambda r: r[0])
-    # digit_rois = [cv2.resize(crop_xywh(roi, rect), size) for rect in rects]
-    digit_rois = [resize_fill_square(crop_xywh(roi, rect), size) for rect in rects]
-    return preprocess_hog(digit_rois)
-
-
-def ocr_digits_by_contour_knn(
-    __roi_gray: Mat,
-    knn_model: cv2_ml_KNearest,
-    *,
-    k=4,
-    size: int = 20,
-) -> int:
-    samples = ocr_digits_by_contour_get_samples(__roi_gray, size)
-    return ocr_digit_samples_knn(samples, knn_model, k)
-
-
-def ocr_rating_class(roi_hsv: Mat):
-    mask_results = [
-        mask_pst(roi_hsv),
-        mask_prs(roi_hsv),
-        mask_ftr(roi_hsv),
-        mask_byd(roi_hsv),
-    ]
-    return max(enumerate(mask_results), key=lambda e: np.count_nonzero(e[1]))[0]

src/arcaea_offline_ocr/phash_db.py

@@ -1,65 +0,0 @@
-import sqlite3
-
-import imagehash
-import numpy as np
-from PIL import Image
-
-
-def hamming_distance_sql_function(user_input, db_entry) -> int:
-    return np.count_nonzero(
-        np.frombuffer(user_input, bool) ^ np.frombuffer(db_entry, bool)
-    )
-
-
-class ImagePHashDatabase:
-    def __init__(self, db_path: str):
-        with sqlite3.connect(db_path) as conn:
-            self.hash_size = int(
-                conn.execute(
-                    "SELECT value FROM properties WHERE key = 'hash_size'"
-                ).fetchone()[0]
-            )
-            self.highfreq_factor = int(
-                conn.execute(
-                    "SELECT value FROM properties WHERE key = 'highfreq_factor'"
-                ).fetchone()[0]
-            )
-            self.built_timestamp = int(
-                conn.execute(
-                    "SELECT value FROM properties WHERE key = 'built_timestamp'"
-                ).fetchone()[0]
-            )
-
-            # self.conn.create_function(
-            #     "HAMMING_DISTANCE",
-            #     2,
-            #     hamming_distance_sql_function,
-            #     deterministic=True,
-            # )
-
-            self.ids = [i[0] for i in conn.execute("SELECT id FROM hashes").fetchall()]
-            self.hashes_byte = [
-                i[0] for i in conn.execute("SELECT hash FROM hashes").fetchall()
-            ]
-            self.hashes = [np.frombuffer(hb, bool) for hb in self.hashes_byte]
-            self.hashes_slice_size = round(len(self.hashes_byte[0]) * 0.25)
-            self.hashes_head = [h[: self.hashes_slice_size] for h in self.hashes]
-            self.hashes_tail = [h[-self.hashes_slice_size :] for h in self.hashes]
-
-    def lookup_hash(self, image_hash: imagehash.ImageHash, *, limit: int = 5):
-        image_hash = image_hash.hash.flatten()
-        # image_hash_head = image_hash[: self.hashes_slice_size]
-        # image_hash_tail = image_hash[-self.hashes_slice_size :]
-        # head_xor_results = [image_hash_head ^ h for h in self.hashes]
-        # tail_xor_results = [image_hash_head ^ h for h in self.hashes]
-        xor_results = [
-            (id, np.count_nonzero(image_hash ^ h))
-            for id, h in zip(self.ids, self.hashes)
-        ]
-        return sorted(xor_results, key=lambda r: r[1])[:limit]
-
-    def lookup_image(self, pil_image: Image.Image):
-        image_hash = imagehash.phash(
-            pil_image, hash_size=self.hash_size, highfreq_factor=self.highfreq_factor
-        )
-        return self.lookup_hash(image_hash)[0]

src/arcaea_offline_ocr/providers/__init__.py

@@ -0,0 +1,12 @@
+from .base import ImageCategory, ImageIdProvider, ImageIdProviderResult, OcrTextProvider
+from .ihdb import ImageHashDatabaseIdProvider
+from .knn import OcrKNearestTextProvider
+
+__all__ = [
+    "ImageCategory",
+    "ImageHashDatabaseIdProvider",
+    "OcrKNearestTextProvider",
+    "ImageIdProvider",
+    "OcrTextProvider",
+    "ImageIdProviderResult",
+]

src/arcaea_offline_ocr/providers/base.py

@@ -0,0 +1,38 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import IntEnum
+from typing import TYPE_CHECKING, Any, Sequence, Optional
+
+if TYPE_CHECKING:
+    from ..types import Mat
+
+
+class OcrTextProvider(ABC):
+    @abstractmethod
+    def result_raw(self, img: "Mat", /, *args, **kwargs) -> Any: ...
+    @abstractmethod
+    def result(self, img: "Mat", /, *args, **kwargs) -> Optional[str]: ...
+
+
+class ImageCategory(IntEnum):
+    JACKET = 0
+    PARTNER_ICON = 1
+
+
+@dataclass(kw_only=True)
+class ImageIdProviderResult:
+    image_id: str
+    category: ImageCategory
+    confidence: float
+
+
+class ImageIdProvider(ABC):
+    @abstractmethod
+    def result(
+        self, img: "Mat", category: ImageCategory, /, *args, **kwargs
+    ) -> ImageIdProviderResult: ...
+
+    @abstractmethod
+    def results(
+        self, img: "Mat", category: ImageCategory, /, *args, **kwargs
+    ) -> Sequence[ImageIdProviderResult]: ...

src/arcaea_offline_ocr/providers/ihdb.py

@@ -0,0 +1,194 @@
+import sqlite3
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from enum import IntEnum
+from typing import TYPE_CHECKING, Any, Callable, List, Optional, TypeVar
+
+from arcaea_offline_ocr.core import hashers
+
+from .base import ImageCategory, ImageIdProvider, ImageIdProviderResult
+
+if TYPE_CHECKING:
+    from arcaea_offline_ocr.types import Mat
+
+
+T = TypeVar("T")
+PROP_KEY_HASH_SIZE = "hash_size"
+PROP_KEY_HIGH_FREQ_FACTOR = "high_freq_factor"
+PROP_KEY_BUILT_AT = "built_at"
+
+
+def _sql_hamming_distance(hash1: bytes, hash2: bytes):
+    assert len(hash1) == len(hash2), "hash size does not match!"
+    count = sum(1 for byte1, byte2 in zip(hash1, hash2) if byte1 != byte2)
+    return count
+
+
+class ImageHashType(IntEnum):
+    AVERAGE = 0
+    DIFFERENCE = 1
+    DCT = 2
+
+
+@dataclass(kw_only=True)
+class ImageHashDatabaseIdProviderResult(ImageIdProviderResult):
+    image_hash_type: ImageHashType
+
+
+class MissingPropertiesError(Exception):
+    keys: List[str]
+
+    def __init__(self, keys, *args):
+        super().__init__(*args)
+        self.keys = keys
+
+
+class ImageHashDatabaseIdProvider(ImageIdProvider):
+    def __init__(self, conn: sqlite3.Connection):
+        self.conn = conn
+        self.conn.create_function("HAMMING_DISTANCE", 2, _sql_hamming_distance)
+
+        self.properties = {
+            PROP_KEY_HASH_SIZE: -1,
+            PROP_KEY_HIGH_FREQ_FACTOR: -1,
+            PROP_KEY_BUILT_AT: None,
+        }
+
+        self._hashes_count = {
+            ImageCategory.JACKET: 0,
+            ImageCategory.PARTNER_ICON: 0,
+        }
+
+        self._hash_length: int = -1
+
+        self._initialize()
+
+    @property
+    def hash_size(self) -> int:
+        return self.properties[PROP_KEY_HASH_SIZE]
+
+    @property
+    def high_freq_factor(self) -> int:
+        return self.properties[PROP_KEY_HIGH_FREQ_FACTOR]
+
+    @property
+    def built_at(self) -> Optional[datetime]:
+        return self.properties.get(PROP_KEY_BUILT_AT)
+
+    @property
+    def hash_length(self):
+        return self._hash_length
+
+    def _initialize(self):
+        def get_property(key, converter: Callable[[Any], T]) -> Optional[T]:
+            result = self.conn.execute(
+                "SELECT value FROM properties WHERE key = ?",
+                (key,),
+            ).fetchone()
+            return converter(result[0]) if result is not None else None
+
+        def set_hashes_count(category: ImageCategory):
+            self._hashes_count[category] = self.conn.execute(
+                "SELECT COUNT(DISTINCT `id`) FROM hashes WHERE category = ?",
+                (category.value,),
+            ).fetchone()[0]
+
+        properties_converter_map = {
+            PROP_KEY_HASH_SIZE: lambda x: int(x),
+            PROP_KEY_HIGH_FREQ_FACTOR: lambda x: int(x),
+            PROP_KEY_BUILT_AT: lambda ts: datetime.fromtimestamp(
+                int(ts) / 1000, tz=timezone.utc
+            ),
+        }
+        required_properties = [PROP_KEY_HASH_SIZE, PROP_KEY_HIGH_FREQ_FACTOR]
+
+        missing_properties = []
+        for property_key, converter in properties_converter_map.items():
+            value = get_property(property_key, converter)
+            if value is None:
+                if property_key in required_properties:
+                    missing_properties.append(property_key)
+
+                continue
+
+            self.properties[property_key] = value
+
+        if missing_properties:
+            raise MissingPropertiesError(keys=missing_properties)
+
+        set_hashes_count(ImageCategory.JACKET)
+        set_hashes_count(ImageCategory.PARTNER_ICON)
+
+        self._hash_length = self.hash_size**2
+
+    def lookup_hash(
+        self, category: ImageCategory, hash_type: ImageHashType, hash: bytes
+    ) -> List[ImageHashDatabaseIdProviderResult]:
+        cursor = self.conn.execute(
+            """
+SELECT
+    `id`,
+    HAMMING_DISTANCE(hash, ?) AS distance
+FROM hashes
+WHERE category = ? AND hash_type = ?
+ORDER BY distance ASC LIMIT 10""",
+            (hash, category.value, hash_type.value),
+        )
+
+        results = []
+        for id_, distance in cursor.fetchall():
+            results.append(
+                ImageHashDatabaseIdProviderResult(
+                    image_id=id_,
+                    category=category,
+                    confidence=(self.hash_length - distance) / self.hash_length,
+                    image_hash_type=hash_type,
+                )
+            )
+
+        return results
+
+    @staticmethod
+    def hash_mat_to_bytes(hash: "Mat") -> bytes:
+        return bytes([255 if b else 0 for b in hash.flatten()])
+
+    def results(self, img: "Mat", category: ImageCategory, /):
+        results: List[ImageHashDatabaseIdProviderResult] = []
+
+        results.extend(
+            self.lookup_hash(
+                category,
+                ImageHashType.AVERAGE,
+                self.hash_mat_to_bytes(hashers.average(img, self.hash_size)),
+            )
+        )
+        results.extend(
+            self.lookup_hash(
+                category,
+                ImageHashType.DIFFERENCE,
+                self.hash_mat_to_bytes(hashers.difference(img, self.hash_size)),
+            )
+        )
+        results.extend(
+            self.lookup_hash(
+                category,
+                ImageHashType.DCT,
+                self.hash_mat_to_bytes(
+                    hashers.dct(img, self.hash_size, self.high_freq_factor)
+                ),
+            )
+        )
+
+        return results
+
+    def result(
+        self,
+        img: "Mat",
+        category: ImageCategory,
+        /,
+        *,
+        hash_type: ImageHashType = ImageHashType.DCT,
+    ):
+        return [
+            it for it in self.results(img, category) if it.image_hash_type == hash_type
+        ][0]

src/arcaea_offline_ocr/providers/knn.py

@@ -0,0 +1,240 @@
+import logging
+import math
+from typing import TYPE_CHECKING, Callable, Optional, Sequence, Tuple
+
+import cv2
+import numpy as np
+
+from ..crop import crop_xywh
+from .base import OcrTextProvider
+
+if TYPE_CHECKING:
+    from cv2.ml import KNearest
+
+    from ..types import Mat
+
+logger = logging.getLogger(__name__)
+
+
+class FixRects:
+    @staticmethod
+    def connect_broken(
+        rects: Sequence[Tuple[int, int, int, int]],
+        img_width: int,
+        img_height: int,
+        tolerance: Optional[int] = None,
+    ):
+        # for a "broken" digit, please refer to
+        # /assets/fix_rects/broken_masked.jpg
+        # the larger "5" in the image is a "broken" digit
+
+        if tolerance is None:
+            tolerance = math.ceil(img_width * 0.08)
+
+        new_rects = []
+        consumed_rects = []
+        for rect in rects:
+            if rect in consumed_rects:
+                continue
+
+            x, _, w, h = rect
+            # grab those small rects
+            if not img_height * 0.1 <= h <= img_height * 0.6:
+                continue
+
+            group = []
+            # see if there's other rects that have near left & right borders
+            for other_rect in rects:
+                if rect == other_rect:
+                    continue
+                ox, _, ow, _ = other_rect
+                if abs(x - ox) < tolerance and abs((x + w) - (ox + ow)) < tolerance:
+                    group.append(other_rect)
+
+            if group:
+                group.append(rect)
+                consumed_rects.extend(group)
+                # calculate the new rect
+                new_x = min(r[0] for r in group)
+                new_y = min(r[1] for r in group)
+                new_right = max(r[0] + r[2] for r in group)
+                new_bottom = max(r[1] + r[3] for r in group)
+                new_w = new_right - new_x
+                new_h = new_bottom - new_y
+                new_rects.append((new_x, new_y, new_w, new_h))
+
+        return_rects = [r for r in rects if r not in consumed_rects]
+        return_rects.extend(new_rects)
+        return return_rects
+
+    @staticmethod
+    def split_connected(
+        img_masked: "Mat",
+        rects: Sequence[Tuple[int, int, int, int]],
+        rect_wh_ratio: float = 1.05,
+        width_range_ratio: float = 0.1,
+    ):
+        connected_rects = []
+        new_rects = []
+        for rect in rects:
+            rx, ry, rw, rh = rect
+            if rw / rh <= rect_wh_ratio:
+                continue
+
+            connected_rects.append(rect)
+
+            # find the thinnest part
+            border_ignore = round(rw * width_range_ratio)
+            img_cropped = crop_xywh(
+                img_masked,
+                (border_ignore, ry, rw - border_ignore, rh),
+            )
+            white_pixels = {}  # dict[x, white_pixel_number]
+            for i in range(img_cropped.shape[1]):
+                col = img_cropped[:, i]
+                white_pixels[rx + border_ignore + i] = np.count_nonzero(col > 200)
+
+            if all(v == 0 for v in white_pixels.values()):
+                return rects
+
+            least_white_pixels = min(v for v in white_pixels.values() if v > 0)
+            x_values = [
+                x for x, pixel in white_pixels.items() if pixel == least_white_pixels
+            ]
+            # select only middle values
+            x_mean = np.mean(x_values)
+            x_std = np.std(x_values)
+            x_values = [
+                x for x in x_values if x_mean - x_std * 1.5 <= x <= x_mean + x_std * 1.5
+            ]
+            x_mid = round(np.median(x_values))
+
+            # split the rect
+            new_rects.extend(
+                [(rx, ry, x_mid - rx, rh), (x_mid, ry, rx + rw - x_mid, rh)]
+            )
+
+        return_rects = [r for r in rects if r not in connected_rects]
+        return_rects.extend(new_rects)
+        return return_rects
+
+
+def resize_fill_square(img: "Mat", target: int = 20):
+    h, w = img.shape[:2]
+    if h > w:
+        new_h = target
+        new_w = round(w * (target / h))
+    else:
+        new_w = target
+        new_h = round(h * (target / w))
+    resized = cv2.resize(img, (new_w, new_h))
+
+    border_size = math.ceil((max(new_w, new_h) - min(new_w, new_h)) / 2)
+    if new_w < new_h:
+        resized = cv2.copyMakeBorder(
+            resized, 0, 0, border_size, border_size, cv2.BORDER_CONSTANT
+        )
+    else:
+        resized = cv2.copyMakeBorder(
+            resized, border_size, border_size, 0, 0, cv2.BORDER_CONSTANT
+        )
+    return cv2.resize(resized, (target, target))
+
+
+def preprocess_hog(digit_rois):
+    # https://learnopencv.com/handwritten-digits-classification-an-opencv-c-python-tutorial/
+    samples = []
+    for digit in digit_rois:
+        hog = cv2.HOGDescriptor((20, 20), (10, 10), (5, 5), (10, 10), 9)
+        hist = hog.compute(digit)
+        samples.append(hist)
+    return np.float32(samples)
+
+
+def ocr_digit_samples_knn(__samples, knn_model: cv2.ml.KNearest, k: int = 4):
+    _, results, _, _ = knn_model.findNearest(__samples, k)
+    return [int(r) for r in results.ravel()]
+
+
+class OcrKNearestTextProvider(OcrTextProvider):
+    _ContourFilter = Callable[["Mat"], bool]
+    _RectsFilter = Callable[[Sequence[int]], bool]
+
+    def __init__(self, model: "KNearest"):
+        self.model = model
+
+    def contours(
+        self, img: "Mat", /, *, contours_filter: Optional[_ContourFilter] = None
+    ):
+        cnts, _ = cv2.findContours(img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+        if contours_filter:
+            cnts = list(filter(contours_filter, cnts))
+
+        return cnts
+
+    def result_raw(
+        self,
+        img: "Mat",
+        /,
+        *,
+        fix_rects: bool = True,
+        contours_filter: Optional[_ContourFilter] = None,
+        rects_filter: Optional[_RectsFilter] = None,
+    ):
+        """
+        :param img: grayscaled roi
+        """
+
+        try:
+            cnts, _ = cv2.findContours(img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            if contours_filter:
+                cnts = list(filter(contours_filter, cnts))
+
+            rects = [cv2.boundingRect(cnt) for cnt in cnts]
+            if fix_rects and rects_filter:
+                rects = FixRects.connect_broken(rects, img.shape[1], img.shape[0])  # type: ignore
+                rects = list(filter(rects_filter, rects))
+                rects = FixRects.split_connected(img, rects)
+            elif fix_rects:
+                rects = FixRects.connect_broken(rects, img.shape[1], img.shape[0])  # type: ignore
+                rects = FixRects.split_connected(img, rects)
+            elif rects_filter:
+                rects = list(filter(rects_filter, rects))
+
+            rects = sorted(rects, key=lambda r: r[0])
+
+            digits = []
+            for rect in rects:
+                digit = crop_xywh(img, rect)
+                digit = resize_fill_square(digit, 20)
+                digits.append(digit)
+            samples = preprocess_hog(digits)
+            return ocr_digit_samples_knn(samples, self.model)
+        except Exception:
+            logger.exception("Error occurred during KNearest OCR")
+            return None
+
+    def result(
+        self,
+        img: "Mat",
+        /,
+        *,
+        fix_rects: bool = True,
+        contours_filter: Optional[_ContourFilter] = None,
+        rects_filter: Optional[_RectsFilter] = None,
+    ):
+        """
+        :param img: grayscaled roi
+        """
+
+        raw = self.result_raw(
+            img,
+            fix_rects=fix_rects,
+            contours_filter=contours_filter,
+            rects_filter=rects_filter,
+        )
+        return (
+            "".join(["".join(str(r) for r in raw if r > -1)])
+            if raw is not None
+            else None
+        )

src/arcaea_offline_ocr/scenarios/b30/__init__.py

@@ -0,0 +1,3 @@
+from .chieri import ChieriBotV4Best30Scenario
+
+__all__ = ["ChieriBotV4Best30Scenario"]

src/arcaea_offline_ocr/scenarios/b30/base.py

@@ -0,0 +1,22 @@
+from abc import abstractmethod
+from typing import TYPE_CHECKING, List
+
+from arcaea_offline_ocr.scenarios.base import OcrScenario, OcrScenarioResult
+
+if TYPE_CHECKING:
+    from arcaea_offline_ocr.types import Mat
+
+
+class Best30Scenario(OcrScenario):
+    @abstractmethod
+    def components(self, img: "Mat", /) -> List["Mat"]: ...
+
+    @abstractmethod
+    def result(self, component_img: "Mat", /, *args, **kwargs) -> OcrScenarioResult: ...
+
+    @abstractmethod
+    def results(self, img: "Mat", /, *args, **kwargs) -> List[OcrScenarioResult]:
+        """
+        Commonly a shorthand for `[self.result(comp) for comp in self.components(img)]`
+        """
+        ...

src/arcaea_offline_ocr/scenarios/b30/chieri/__init__.py

@@ -0,0 +1,3 @@
+from .v4 import ChieriBotV4Best30Scenario
+
+__all__ = ["ChieriBotV4Best30Scenario"]

src/arcaea_offline_ocr/scenarios/b30/chieri/v4/__init__.py

@@ -0,0 +1,3 @@
+from .impl import ChieriBotV4Best30Scenario
+
+__all__ = ["ChieriBotV4Best30Scenario"]

src/arcaea_offline_ocr/scenarios/b30/chieri/v4/colors.py

@@ -27,11 +27,11 @@ FAR_BG_MAX_HSV = np.array([20, 255, 255], np.uint8)
 LOST_BG_MIN_HSV = np.array([115, 60, 150], np.uint8)
 LOST_BG_MAX_HSV = np.array([140, 255, 255], np.uint8)
 
-BYD_MIN_HSV = (158, 120, 0)
+BYD_MIN_HSV = np.array([158, 120, 0], np.uint8)
-BYD_MAX_HSV = (172, 255, 255)
+BYD_MAX_HSV = np.array([172, 255, 255], np.uint8)
 
-FTR_MIN_HSV = (145, 70, 0)
+FTR_MIN_HSV = np.array([145, 70, 0], np.uint8)
-FTR_MAX_HSV = (160, 255, 255)
+FTR_MAX_HSV = np.array([160, 255, 255], np.uint8)
 
-PRS_MIN_HSV = (45, 60, 0)
+PRS_MIN_HSV = np.array([45, 60, 0], np.uint8)
-PRS_MAX_HSV = (70, 255, 255)
+PRS_MAX_HSV = np.array([70, 255, 255], np.uint8)

src/arcaea_offline_ocr/scenarios/b30/chieri/v4/impl.py

@@ -1,57 +1,47 @@
-from math import floor
 from typing import List, Optional, Tuple
 
 import cv2
 import numpy as np
-from PIL import Image
 
-from ....crop import crop_xywh
+from arcaea_offline_ocr.crop import crop_xywh
-from ....ocr import FixRects, ocr_digits_by_contour_knn, preprocess_hog
+from arcaea_offline_ocr.providers import (
-from ....phash_db import ImagePHashDatabase
+    ImageCategory,
-from ....sift_db import SIFTDatabase
+    ImageIdProvider,
-from ....types import Mat, cv2_ml_KNearest
+    OcrKNearestTextProvider,
-from ....utils import construct_int_xywh_rect
+)
-from ...shared import B30OcrResultItem
+from arcaea_offline_ocr.scenarios.b30.base import Best30Scenario
-from .colors import *
+from arcaea_offline_ocr.scenarios.base import OcrScenarioResult
+from arcaea_offline_ocr.types import Mat
+
+from .colors import (
+    BYD_MAX_HSV,
+    BYD_MIN_HSV,
+    FAR_BG_MAX_HSV,
+    FAR_BG_MIN_HSV,
+    FTR_MAX_HSV,
+    FTR_MIN_HSV,
+    LOST_BG_MAX_HSV,
+    LOST_BG_MIN_HSV,
+    PRS_MAX_HSV,
+    PRS_MIN_HSV,
+    PURE_BG_MAX_HSV,
+    PURE_BG_MIN_HSV,
+)
 from .rois import ChieriBotV4Rois
 
 
-class ChieriBotV4Ocr:
+class ChieriBotV4Best30Scenario(Best30Scenario):
     def __init__(
         self,
-        score_knn: cv2_ml_KNearest,
+        score_knn_provider: OcrKNearestTextProvider,
-        pfl_knn: cv2_ml_KNearest,
+        pfl_knn_provider: OcrKNearestTextProvider,
-        phash_db: ImagePHashDatabase,
+        image_id_provider: ImageIdProvider,
-        factor: Optional[float] = 1.0,
+        factor: float = 1.0,
     ):
-        self.__score_knn = score_knn
-        self.__pfl_knn = pfl_knn
-        self.__phash_db = phash_db
         self.__rois = ChieriBotV4Rois(factor)
-
+        self.pfl_knn_provider = pfl_knn_provider
-    @property
+        self.score_knn_provider = score_knn_provider
-    def score_knn(self):
+        self.image_id_provider = image_id_provider
-        return self.__score_knn
-
-    @score_knn.setter
-    def score_knn(self, knn_digits_model: Mat):
-        self.__score_knn = knn_digits_model
-
-    @property
-    def pfl_knn(self):
-        return self.__pfl_knn
-
-    @pfl_knn.setter
-    def pfl_knn(self, knn_digits_model: Mat):
-        self.__pfl_knn = knn_digits_model
-
-    @property
-    def phash_db(self):
-        return self.__phash_db
-
-    @phash_db.setter
-    def phash_db(self, phash_db: ImagePHashDatabase):
-        self.__phash_db = phash_db
 
     @property
     def rois(self):
@@ -69,9 +59,8 @@ class ChieriBotV4Ocr:
         self.factor = img.shape[0] / 4400
 
     def ocr_component_rating_class(self, component_bgr: Mat) -> int:
-        rating_class_rect = construct_int_xywh_rect(
+        rating_class_rect = self.rois.component_rois.rating_class_rect.rounded()
-            self.rois.component_rois.rating_class_rect
+
-        )
         rating_class_roi = crop_xywh(component_bgr, rating_class_rect)
         rating_class_roi = cv2.cvtColor(rating_class_roi, cv2.COLOR_BGR2HSV)
         rating_class_masks = [
@@ -85,39 +74,16 @@ class ChieriBotV4Ocr:
         else:
             return max(enumerate(rating_class_results), key=lambda i: i[1])[0] + 1
 
-    # def ocr_component_title(self, component_bgr: Mat) -> str:
+    def ocr_component_song_id_results(self, component_bgr: Mat):
-    #     # sourcery skip: inline-immediately-returned-variable
+        jacket_rect = self.rois.component_rois.jacket_rect.floored()
-    #     title_rect = construct_int_xywh_rect(self.rois.component_rois.title_rect)
-    #     title_roi = crop_xywh(component_bgr, title_rect)
-    #     ocr_result = self.sift_db.ocr(title_roi, cls=False)
-    #     title = ocr_result[0][-1][1][0] if ocr_result and ocr_result[0] else ""
-    #     return title
-
-    def ocr_component_song_id(self, component_bgr: Mat):
-        jacket_rect = construct_int_xywh_rect(
-            self.rois.component_rois.jacket_rect, floor
-        )
         jacket_roi = cv2.cvtColor(
             crop_xywh(component_bgr, jacket_rect), cv2.COLOR_BGR2GRAY
         )
-        return self.phash_db.lookup_image(Image.fromarray(jacket_roi))[0]
+        return self.image_id_provider.results(jacket_roi, ImageCategory.JACKET)
-
-    # def ocr_component_score_paddle(self, component_bgr: Mat) -> int:
-    #     # sourcery skip: inline-immediately-returned-variable
-    #     score_rect = construct_int_xywh_rect(self.rois.component_rois.score_rect)
-    #     score_roi = cv2.cvtColor(
-    #         crop_xywh(component_bgr, score_rect), cv2.COLOR_BGR2GRAY
-    #     )
-    #     _, score_roi = cv2.threshold(
-    #         score_roi, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU
-    #     )
-    #     score_str = self.sift_db.ocr(score_roi, cls=False)[0][-1][1][0]
-    #     score = int(score_str.replace("'", "").replace(" ", ""))
-    #     return score
 
     def ocr_component_score_knn(self, component_bgr: Mat) -> int:
         # sourcery skip: inline-immediately-returned-variable
-        score_rect = construct_int_xywh_rect(self.rois.component_rois.score_rect)
+        score_rect = self.rois.component_rois.score_rect.rounded()
         score_roi = cv2.cvtColor(
             crop_xywh(component_bgr, score_rect), cv2.COLOR_BGR2GRAY
         )
@@ -135,9 +101,13 @@ class ChieriBotV4Ocr:
             if rect[3] > score_roi.shape[0] * 0.5:
                 continue
             score_roi = cv2.fillPoly(score_roi, [contour], 0)
-        return ocr_digits_by_contour_knn(score_roi, self.score_knn)
 
-    def find_pfl_rects(self, component_pfl_processed: Mat) -> List[List[int]]:
+        ocr_result = self.score_knn_provider.result(score_roi)
+        return int(ocr_result) if ocr_result else 0
+
+    def find_pfl_rects(
+        self, component_pfl_processed: Mat
+    ) -> List[Tuple[int, int, int, int]]:
         # sourcery skip: inline-immediately-returned-variable
         pfl_roi_find = cv2.morphologyEx(
             component_pfl_processed,
@@ -164,7 +134,7 @@ class ChieriBotV4Ocr:
         return pfl_rects_adjusted
 
     def preprocess_component_pfl(self, component_bgr: Mat) -> Mat:
-        pfl_rect = construct_int_xywh_rect(self.rois.component_rois.pfl_rect)
+        pfl_rect = self.rois.component_rois.pfl_rect.rounded()
         pfl_roi = crop_xywh(component_bgr, pfl_rect)
         pfl_roi_hsv = cv2.cvtColor(pfl_roi, cv2.COLOR_BGR2HSV)
 
@@ -211,60 +181,43 @@ class ChieriBotV4Ocr:
             pure_far_lost = []
             for pfl_roi_rect in pfl_rects:
                 roi = crop_xywh(pfl_roi, pfl_roi_rect)
-                digit_contours, _ = cv2.findContours(
+                result = self.pfl_knn_provider.result(roi)
-                    roi, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+                pure_far_lost.append(int(result) if result else None)
-                )
-                digit_rects = [cv2.boundingRect(c) for c in digit_contours]
-                digit_rects = FixRects.connect_broken(
-                    digit_rects, roi.shape[1], roi.shape[0]
-                )
-                digit_rects = FixRects.split_connected(roi, digit_rects)
-                digit_rects = sorted(digit_rects, key=lambda r: r[0])
-                digits = []
-                for digit_rect in digit_rects:
-                    digit = crop_xywh(roi, digit_rect)
-                    digit = cv2.resize(digit, (20, 20))
-                    digits.append(digit)
-                samples = preprocess_hog(digits)
 
-                _, results, _, _ = self.pfl_knn.findNearest(samples, 4)
-                results = [str(int(i)) for i in results.ravel()]
-                pure_far_lost.append(int("".join(results)))
             return tuple(pure_far_lost)
         except Exception:
             return (None, None, None)
 
-    # def ocr_component_date(self, component_bgr: Mat):
+    def ocr_component(self, component_bgr: Mat) -> OcrScenarioResult:
-    #     date_rect = construct_int_xywh_rect(self.rois.component_rois.date_rect)
-    #     date_roi = cv2.cvtColor(crop_xywh(component_bgr, date_rect), cv2.COLOR_BGR2GRAY)
-    #     _, date_roi = cv2.threshold(
-    #         date_roi, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU
-    #     )
-    #     date_str = self.sift_db.ocr(date_roi, cls=False)[0][-1][1][0]
-    #     return date_str
-
-    def ocr_component(self, component_bgr: Mat) -> B30OcrResultItem:
         component_blur = cv2.GaussianBlur(component_bgr, (5, 5), 0)
         rating_class = self.ocr_component_rating_class(component_blur)
-        song_id = self.ocr_component_song_id(component_bgr)
+        song_id_results = self.ocr_component_song_id_results(component_bgr)
-        # title = self.ocr_component_title(component_blur)
         # score = self.ocr_component_score(component_blur)
         score = self.ocr_component_score_knn(component_bgr)
         pure, far, lost = self.ocr_component_pfl(component_bgr)
-        return B30OcrResultItem(
+        return OcrScenarioResult(
-            song_id=song_id,
+            song_id=song_id_results[0].image_id,
+            song_id_results=song_id_results,
             rating_class=rating_class,
-            # title=title,
             score=score,
             pure=pure,
             far=far,
             lost=lost,
-            date=None,
+            played_at=None,
         )
 
-    def ocr(self, img_bgr: Mat) -> List[B30OcrResultItem]:
+    def components(self, img: Mat, /):
-        self.set_factor(img_bgr)
+        """
-        return [
+        :param img: BGR format image
-            self.ocr_component(component_bgr)
+        """
-            for component_bgr in self.rois.components(img_bgr)
+        self.set_factor(img)
-        ]
+        return self.rois.components(img)
+
+    def result(self, component_img: Mat, /):
+        return self.ocr_component(component_img)
+
+    def results(self, img: Mat, /) -> List[OcrScenarioResult]:
+        """
+        :param img: BGR format image
+        """
+        return [self.ocr_component(component) for component in self.components(img)]

src/arcaea_offline_ocr/scenarios/b30/chieri/v4/rois.py

@@ -1,12 +1,11 @@
-from typing import List, Optional
+from typing import List
 
-from ....crop import crop_xywh
+from arcaea_offline_ocr.crop import crop_xywh
-from ....types import Mat, XYWHRect
+from arcaea_offline_ocr.types import Mat, XYWHRect
-from ....utils import apply_factor, construct_int_xywh_rect
 
 
 class ChieriBotV4ComponentRois:
-    def __init__(self, factor: Optional[float] = 1.0):
+    def __init__(self, factor: float = 1.0):
         self.__factor = factor
 
     @property
@@ -19,43 +18,43 @@ class ChieriBotV4ComponentRois:
 
     @property
     def top_font_color_detect(self):
-        return apply_factor((35, 10, 120, 100), self.factor)
+        return XYWHRect(35, 10, 120, 100), self.factor
 
     @property
     def bottom_font_color_detect(self):
-        return apply_factor((30, 125, 175, 110), self.factor)
+        return XYWHRect(30, 125, 175, 110) * self.factor
 
     @property
     def bg_point(self):
-        return apply_factor((75, 10), self.factor)
+        return (75 * self.factor, 10 * self.factor)
 
     @property
     def rating_class_rect(self):
-        return apply_factor((21, 40, 7, 20), self.factor)
+        return XYWHRect(21, 40, 7, 20) * self.factor
 
     @property
     def title_rect(self):
-        return apply_factor((35, 10, 430, 50), self.factor)
+        return XYWHRect(35, 10, 430, 50) * self.factor
 
     @property
     def jacket_rect(self):
-        return apply_factor((263, 0, 239, 239), self.factor)
+        return XYWHRect(263, 0, 239, 239) * self.factor
 
     @property
     def score_rect(self):
-        return apply_factor((30, 60, 270, 55), self.factor)
+        return XYWHRect(30, 60, 270, 55) * self.factor
 
     @property
     def pfl_rect(self):
-        return apply_factor((50, 125, 80, 100), self.factor)
+        return XYWHRect(50, 125, 80, 100) * self.factor
 
     @property
     def date_rect(self):
-        return apply_factor((205, 200, 225, 25), self.factor)
+        return XYWHRect(205, 200, 225, 25) * self.factor
 
 
 class ChieriBotV4Rois:
-    def __init__(self, factor: Optional[float] = 1.0):
+    def __init__(self, factor: float = 1.0):
         self.__factor = factor
         self.__component_rois = ChieriBotV4ComponentRois(factor)
 
@@ -74,54 +73,53 @@ class ChieriBotV4Rois:
 
     @property
     def top(self):
-        return apply_factor(823, self.factor)
+        return 823 * self.factor
 
     @property
     def left(self):
-        return apply_factor(107, self.factor)
+        return 107 * self.factor
 
     @property
     def width(self):
-        return apply_factor(502, self.factor)
+        return 502 * self.factor
 
     @property
     def height(self):
-        return apply_factor(240, self.factor)
+        return 240 * self.factor
 
     @property
     def vertical_gap(self):
-        return apply_factor(74, self.factor)
+        return 74 * self.factor
 
     @property
     def horizontal_gap(self):
-        return apply_factor(40, self.factor)
+        return 40 * self.factor
 
     @property
     def horizontal_items(self):
         return 3
 
-    @property
+    vertical_items = 10
-    def vertical_items(self):
-        return 10
 
     @property
     def b33_vertical_gap(self):
-        return apply_factor(121, self.factor)
+        return 121 * self.factor
 
     def components(self, img_bgr: Mat) -> List[Mat]:
         first_rect = XYWHRect(x=self.left, y=self.top, w=self.width, h=self.height)
         results = []
 
+        last_rect = first_rect
         for vi in range(self.vertical_items):
             rect = XYWHRect(*first_rect)
             rect += (0, (self.vertical_gap + self.height) * vi, 0, 0)
             for hi in range(self.horizontal_items):
                 if hi > 0:
                     rect += ((self.width + self.horizontal_gap), 0, 0, 0)
-                int_rect = construct_int_xywh_rect(rect)
+                results.append(crop_xywh(img_bgr, rect.rounded()))
-                results.append(crop_xywh(img_bgr, int_rect))
+            last_rect = rect
 
-        rect += (
+        last_rect += (
             -(self.width + self.horizontal_gap) * 2,
             self.height + self.b33_vertical_gap,
             0,
@@ -129,8 +127,7 @@ class ChieriBotV4Rois:
         )
         for hi in range(self.horizontal_items):
             if hi > 0:
-                rect += ((self.width + self.horizontal_gap), 0, 0, 0)
+                last_rect += ((self.width + self.horizontal_gap), 0, 0, 0)
-            int_rect = construct_int_xywh_rect(rect)
+            results.append(crop_xywh(img_bgr, last_rect.rounded()))
-            results.append(crop_xywh(img_bgr, int_rect))
 
         return results

src/arcaea_offline_ocr/scenarios/base.py

@@ -0,0 +1,38 @@
+from abc import ABC
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Sequence, Optional
+
+from arcaea_offline_ocr.providers import ImageIdProviderResult
+
+
+@dataclass(kw_only=True)
+class OcrScenarioResult:
+    song_id: str
+    rating_class: int
+    score: int
+
+    song_id_results: Sequence[ImageIdProviderResult] = field(default_factory=lambda: [])
+    partner_id_results: Sequence[ImageIdProviderResult] = field(
+        default_factory=lambda: []
+    )
+
+    pure: Optional[int] = None
+    pure_inaccurate: Optional[int] = None
+    pure_early: Optional[int] = None
+    pure_late: Optional[int] = None
+    far: Optional[int] = None
+    far_inaccurate: Optional[int] = None
+    far_early: Optional[int] = None
+    far_late: Optional[int] = None
+    lost: Optional[int] = None
+
+    played_at: Optional[datetime] = None
+    max_recall: Optional[int] = None
+    clear_status: Optional[int] = None
+    clear_type: Optional[int] = None
+    modifier: Optional[int] = None
+
+
+class OcrScenario(ABC):
+    pass

src/arcaea_offline_ocr/scenarios/device/__init__.py

@@ -0,0 +1,13 @@
+from .extractor import DeviceRoisExtractor
+from .impl import DeviceScenario
+from .masker import DeviceRoisMaskerAutoT1, DeviceRoisMaskerAutoT2
+from .rois import DeviceRoisAutoT1, DeviceRoisAutoT2
+
+__all__ = [
+    "DeviceRoisMaskerAutoT1",
+    "DeviceRoisMaskerAutoT2",
+    "DeviceRoisAutoT1",
+    "DeviceRoisAutoT2",
+    "DeviceRoisExtractor",
+    "DeviceScenario",
+]

src/arcaea_offline_ocr/scenarios/device/base.py

@@ -0,0 +1,8 @@
+from abc import abstractmethod
+
+from arcaea_offline_ocr.scenarios.base import OcrScenario, OcrScenarioResult
+
+
+class DeviceScenarioBase(OcrScenario):
+    @abstractmethod
+    def result(self) -> OcrScenarioResult: ...

src/arcaea_offline_ocr/scenarios/device/extractor/__init__.py

@@ -0,0 +1,3 @@
+from .base import DeviceRoisExtractor
+
+__all__ = ["DeviceRoisExtractor"]

src/arcaea_offline_ocr/scenarios/device/extractor/base.py

@@ -0,0 +1,46 @@
+from arcaea_offline_ocr.crop import crop_xywh
+from arcaea_offline_ocr.types import Mat
+
+from ..rois.base import DeviceRois
+
+
+class DeviceRoisExtractor:
+    def __init__(self, img: Mat, rois: DeviceRois):
+        self.img = img
+        self.sizes = rois
+
+    @property
+    def pure(self):
+        return crop_xywh(self.img, self.sizes.pure.rounded())
+
+    @property
+    def far(self):
+        return crop_xywh(self.img, self.sizes.far.rounded())
+
+    @property
+    def lost(self):
+        return crop_xywh(self.img, self.sizes.lost.rounded())
+
+    @property
+    def score(self):
+        return crop_xywh(self.img, self.sizes.score.rounded())
+
+    @property
+    def jacket(self):
+        return crop_xywh(self.img, self.sizes.jacket.rounded())
+
+    @property
+    def rating_class(self):
+        return crop_xywh(self.img, self.sizes.rating_class.rounded())
+
+    @property
+    def max_recall(self):
+        return crop_xywh(self.img, self.sizes.max_recall.rounded())
+
+    @property
+    def clear_status(self):
+        return crop_xywh(self.img, self.sizes.clear_status.rounded())
+
+    @property
+    def partner_icon(self):
+        return crop_xywh(self.img, self.sizes.partner_icon.rounded())

src/arcaea_offline_ocr/scenarios/device/impl.py

@@ -0,0 +1,155 @@
+import cv2
+import numpy as np
+
+from arcaea_offline_ocr.providers import (
+    ImageCategory,
+    ImageIdProvider,
+    OcrKNearestTextProvider,
+)
+from arcaea_offline_ocr.scenarios.base import OcrScenarioResult
+from arcaea_offline_ocr.types import Mat
+
+from .base import DeviceScenarioBase
+from .extractor import DeviceRoisExtractor
+from .masker import DeviceRoisMasker
+
+
+class DeviceScenario(DeviceScenarioBase):
+    def __init__(
+        self,
+        extractor: DeviceRoisExtractor,
+        masker: DeviceRoisMasker,
+        knn_provider: OcrKNearestTextProvider,
+        image_id_provider: ImageIdProvider,
+    ):
+        self.extractor = extractor
+        self.masker = masker
+        self.knn_provider = knn_provider
+        self.image_id_provider = image_id_provider
+
+    def pfl(self, roi_gray: Mat, factor: float = 1.25):
+        def contour_filter(cnt):
+            return cv2.contourArea(cnt) >= 5 * factor
+
+        contours = self.knn_provider.contours(roi_gray)
+        contours_filtered = self.knn_provider.contours(
+            roi_gray, contours_filter=contour_filter
+        )
+
+        roi_ocr = roi_gray.copy()
+        contours_filtered_flattened = {tuple(c.flatten()) for c in contours_filtered}
+        for contour in contours:
+            if tuple(contour.flatten()) in contours_filtered_flattened:
+                continue
+            roi_ocr = cv2.fillPoly(roi_ocr, [contour], [0])
+
+        ocr_result = self.knn_provider.result(
+            roi_ocr,
+            contours_filter=lambda cnt: cv2.contourArea(cnt) >= 5 * factor,
+            rects_filter=lambda rect: rect[2] >= 5 * factor and rect[3] >= 6 * factor,
+        )
+
+        return int(ocr_result) if ocr_result else 0
+
+    def pure(self):
+        return self.pfl(self.masker.pure(self.extractor.pure))
+
+    def far(self):
+        return self.pfl(self.masker.far(self.extractor.far))
+
+    def lost(self):
+        return self.pfl(self.masker.lost(self.extractor.lost))
+
+    def score(self):
+        roi = self.masker.score(self.extractor.score)
+        contours = self.knn_provider.contours(roi)
+        for contour in contours:
+            if (
+                cv2.boundingRect(contour)[3] < roi.shape[0] * 0.6
+            ):  # h < score_component_h * 0.6
+                roi = cv2.fillPoly(roi, [contour], [0])
+        ocr_result = self.knn_provider.result(roi)
+        return int(ocr_result) if ocr_result else 0
+
+    def rating_class(self):
+        roi = self.extractor.rating_class
+        results = [
+            self.masker.rating_class_pst(roi),
+            self.masker.rating_class_prs(roi),
+            self.masker.rating_class_ftr(roi),
+            self.masker.rating_class_byd(roi),
+            self.masker.rating_class_etr(roi),
+        ]
+        return max(enumerate(results), key=lambda i: np.count_nonzero(i[1]))[0]
+
+    def max_recall(self):
+        ocr_result = self.knn_provider.result(
+            self.masker.max_recall(self.extractor.max_recall)
+        )
+        return int(ocr_result) if ocr_result else None
+
+    def clear_status(self):
+        roi = self.extractor.clear_status
+        results = [
+            self.masker.clear_status_track_lost(roi),
+            self.masker.clear_status_track_complete(roi),
+            self.masker.clear_status_full_recall(roi),
+            self.masker.clear_status_pure_memory(roi),
+        ]
+        return max(enumerate(results), key=lambda i: np.count_nonzero(i[1]))[0]
+
+    def song_id_results(self):
+        return self.image_id_provider.results(
+            cv2.cvtColor(self.extractor.jacket, cv2.COLOR_BGR2GRAY),
+            ImageCategory.JACKET,
+        )
+
+    @staticmethod
+    def preprocess_char_icon(img_gray: Mat):
+        h, w = img_gray.shape[:2]
+        img = cv2.copyMakeBorder(img_gray, max(w - h, 0), 0, 0, 0, cv2.BORDER_REPLICATE)
+        h, w = img.shape[:2]
+        img = cv2.fillPoly(
+            img,
+            [
+                np.array([[0, 0], [round(w / 2), 0], [0, round(h / 2)]], np.int32),
+                np.array([[w, 0], [round(w / 2), 0], [w, round(h / 2)]], np.int32),
+                np.array([[0, h], [round(w / 2), h], [0, round(h / 2)]], np.int32),
+                np.array([[w, h], [round(w / 2), h], [w, round(h / 2)]], np.int32),
+            ],
+            (128,),
+        )
+        return img
+
+    def partner_id_results(self):
+        return self.image_id_provider.results(
+            self.preprocess_char_icon(
+                cv2.cvtColor(self.extractor.partner_icon, cv2.COLOR_BGR2GRAY)
+            ),
+            ImageCategory.PARTNER_ICON,
+        )
+
+    def result(self):
+        rating_class = self.rating_class()
+        pure = self.pure()
+        far = self.far()
+        lost = self.lost()
+        score = self.score()
+        max_recall = self.max_recall()
+        clear_status = self.clear_status()
+
+        song_id_results = self.song_id_results()
+        partner_id_results = self.partner_id_results()
+
+        return OcrScenarioResult(
+            song_id=song_id_results[0].image_id,
+            song_id_results=song_id_results,
+            rating_class=rating_class,
+            pure=pure,
+            far=far,
+            lost=lost,
+            score=score,
+            max_recall=max_recall,
+            partner_id_results=partner_id_results,
+            clear_status=clear_status,
+        )

src/arcaea_offline_ocr/scenarios/device/masker/__init__.py

@@ -0,0 +1,9 @@
+from .auto import DeviceRoisMaskerAuto, DeviceRoisMaskerAutoT1, DeviceRoisMaskerAutoT2
+from .base import DeviceRoisMasker
+
+__all__ = [
+    "DeviceRoisMaskerAuto",
+    "DeviceRoisMaskerAutoT1",
+    "DeviceRoisMaskerAutoT2",
+    "DeviceRoisMasker",
+]

src/arcaea_offline_ocr/scenarios/device/masker/auto.py

@@ -0,0 +1,230 @@
+import cv2
+import numpy as np
+
+from arcaea_offline_ocr.types import Mat
+
+from .base import DeviceRoisMasker
+
+
+class DeviceRoisMaskerAuto(DeviceRoisMasker):
+    @staticmethod
+    def mask_bgr_in_hsv(roi_bgr: Mat, hsv_lower: Mat, hsv_upper: Mat):
+        return cv2.inRange(
+            cv2.cvtColor(roi_bgr, cv2.COLOR_BGR2HSV), hsv_lower, hsv_upper
+        )
+
+
+class DeviceRoisMaskerAutoT1(DeviceRoisMaskerAuto):
+    GRAY_BGR_MIN = np.array([50] * 3, np.uint8)
+    GRAY_BGR_MAX = np.array([160] * 3, np.uint8)
+
+    SCORE_HSV_MIN = np.array([0, 0, 180], np.uint8)
+    SCORE_HSV_MAX = np.array([179, 255, 255], np.uint8)
+
+    PST_HSV_MIN = np.array([100, 50, 80], np.uint8)
+    PST_HSV_MAX = np.array([100, 255, 255], np.uint8)
+
+    PRS_HSV_MIN = np.array([43, 40, 75], np.uint8)
+    PRS_HSV_MAX = np.array([50, 155, 190], np.uint8)
+
+    FTR_HSV_MIN = np.array([149, 30, 0], np.uint8)
+    FTR_HSV_MAX = np.array([155, 181, 150], np.uint8)
+
+    BYD_HSV_MIN = np.array([170, 50, 50], np.uint8)
+    BYD_HSV_MAX = np.array([179, 210, 198], np.uint8)
+
+    ETR_HSV_MIN = np.array([130, 60, 80], np.uint8)
+    ETR_HSV_MAX = np.array([140, 145, 180], np.uint8)
+
+    TRACK_LOST_HSV_MIN = np.array([170, 75, 90], np.uint8)
+    TRACK_LOST_HSV_MAX = np.array([175, 170, 160], np.uint8)
+
+    TRACK_COMPLETE_HSV_MIN = np.array([140, 0, 50], np.uint8)
+    TRACK_COMPLETE_HSV_MAX = np.array([145, 50, 130], np.uint8)
+
+    FULL_RECALL_HSV_MIN = np.array([140, 60, 80], np.uint8)
+    FULL_RECALL_HSV_MAX = np.array([150, 130, 145], np.uint8)
+
+    PURE_MEMORY_HSV_MIN = np.array([90, 70, 80], np.uint8)
+    PURE_MEMORY_HSV_MAX = np.array([110, 200, 175], np.uint8)
+
+    @classmethod
+    def gray(cls, roi_bgr: Mat) -> Mat:
+        bgr_value_equal_mask = np.max(roi_bgr, axis=2) - np.min(roi_bgr, axis=2) <= 5
+        img_bgr = roi_bgr.copy()
+        img_bgr[~bgr_value_equal_mask] = np.array([0, 0, 0], roi_bgr.dtype)
+        img_bgr = cv2.erode(img_bgr, cv2.getStructuringElement(cv2.MORPH_RECT, (2, 2)))
+        img_bgr = cv2.dilate(img_bgr, cv2.getStructuringElement(cv2.MORPH_RECT, (1, 1)))
+        return cv2.inRange(img_bgr, cls.GRAY_BGR_MIN, cls.GRAY_BGR_MAX)
+
+    @classmethod
+    def pure(cls, roi_bgr: Mat) -> Mat:
+        return cls.gray(roi_bgr)
+
+    @classmethod
+    def far(cls, roi_bgr: Mat) -> Mat:
+        return cls.gray(roi_bgr)
+
+    @classmethod
+    def lost(cls, roi_bgr: Mat) -> Mat:
+        return cls.gray(roi_bgr)
+
+    @classmethod
+    def score(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(roi_bgr, cls.SCORE_HSV_MIN, cls.SCORE_HSV_MAX)
+
+    @classmethod
+    def rating_class_pst(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(roi_bgr, cls.PST_HSV_MIN, cls.PST_HSV_MAX)
+
+    @classmethod
+    def rating_class_prs(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(roi_bgr, cls.PRS_HSV_MIN, cls.PRS_HSV_MAX)
+
+    @classmethod
+    def rating_class_ftr(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(roi_bgr, cls.FTR_HSV_MIN, cls.FTR_HSV_MAX)
+
+    @classmethod
+    def rating_class_byd(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(roi_bgr, cls.BYD_HSV_MIN, cls.BYD_HSV_MAX)
+
+    @classmethod
+    def rating_class_etr(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(roi_bgr, cls.ETR_HSV_MIN, cls.ETR_HSV_MAX)
+
+    @classmethod
+    def max_recall(cls, roi_bgr: Mat) -> Mat:
+        return cls.gray(roi_bgr)
+
+    @classmethod
+    def clear_status_track_lost(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(
+            roi_bgr, cls.TRACK_LOST_HSV_MIN, cls.TRACK_LOST_HSV_MAX
+        )
+
+    @classmethod
+    def clear_status_track_complete(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(
+            roi_bgr, cls.TRACK_COMPLETE_HSV_MIN, cls.TRACK_COMPLETE_HSV_MAX
+        )
+
+    @classmethod
+    def clear_status_full_recall(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(
+            roi_bgr, cls.FULL_RECALL_HSV_MIN, cls.FULL_RECALL_HSV_MAX
+        )
+
+    @classmethod
+    def clear_status_pure_memory(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(
+            roi_bgr, cls.PURE_MEMORY_HSV_MIN, cls.PURE_MEMORY_HSV_MAX
+        )
+
+
+class DeviceRoisMaskerAutoT2(DeviceRoisMaskerAuto):
+    PFL_HSV_MIN = np.array([0, 0, 248], np.uint8)
+    PFL_HSV_MAX = np.array([179, 40, 255], np.uint8)
+
+    SCORE_HSV_MIN = np.array([0, 0, 180], np.uint8)
+    SCORE_HSV_MAX = np.array([179, 255, 255], np.uint8)
+
+    PST_HSV_MIN = np.array([100, 50, 80], np.uint8)
+    PST_HSV_MAX = np.array([100, 255, 255], np.uint8)
+
+    PRS_HSV_MIN = np.array([43, 40, 75], np.uint8)
+    PRS_HSV_MAX = np.array([50, 155, 190], np.uint8)
+
+    FTR_HSV_MIN = np.array([149, 30, 0], np.uint8)
+    FTR_HSV_MAX = np.array([155, 181, 150], np.uint8)
+
+    BYD_HSV_MIN = np.array([170, 50, 50], np.uint8)
+    BYD_HSV_MAX = np.array([179, 210, 198], np.uint8)
+
+    ETR_HSV_MIN = np.array([130, 60, 80], np.uint8)
+    ETR_HSV_MAX = np.array([140, 145, 180], np.uint8)
+
+    MAX_RECALL_HSV_MIN = np.array([125, 0, 0], np.uint8)
+    MAX_RECALL_HSV_MAX = np.array([145, 100, 150], np.uint8)
+
+    TRACK_LOST_HSV_MIN = np.array([170, 75, 90], np.uint8)
+    TRACK_LOST_HSV_MAX = np.array([175, 170, 160], np.uint8)
+
+    TRACK_COMPLETE_HSV_MIN = np.array([140, 0, 50], np.uint8)
+    TRACK_COMPLETE_HSV_MAX = np.array([145, 50, 130], np.uint8)
+
+    FULL_RECALL_HSV_MIN = np.array([140, 60, 80], np.uint8)
+    FULL_RECALL_HSV_MAX = np.array([150, 130, 145], np.uint8)
+
+    PURE_MEMORY_HSV_MIN = np.array([90, 70, 80], np.uint8)
+    PURE_MEMORY_HSV_MAX = np.array([110, 200, 175], np.uint8)
+
+    @classmethod
+    def pfl(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(roi_bgr, cls.PFL_HSV_MIN, cls.PFL_HSV_MAX)
+
+    @classmethod
+    def pure(cls, roi_bgr: Mat) -> Mat:
+        return cls.pfl(roi_bgr)
+
+    @classmethod
+    def far(cls, roi_bgr: Mat) -> Mat:
+        return cls.pfl(roi_bgr)
+
+    @classmethod
+    def lost(cls, roi_bgr: Mat) -> Mat:
+        return cls.pfl(roi_bgr)
+
+    @classmethod
+    def score(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(roi_bgr, cls.SCORE_HSV_MIN, cls.SCORE_HSV_MAX)
+
+    @classmethod
+    def rating_class_pst(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(roi_bgr, cls.PST_HSV_MIN, cls.PST_HSV_MAX)
+
+    @classmethod
+    def rating_class_prs(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(roi_bgr, cls.PRS_HSV_MIN, cls.PRS_HSV_MAX)
+
+    @classmethod
+    def rating_class_ftr(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(roi_bgr, cls.FTR_HSV_MIN, cls.FTR_HSV_MAX)
+
+    @classmethod
+    def rating_class_byd(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(roi_bgr, cls.BYD_HSV_MIN, cls.BYD_HSV_MAX)
+
+    @classmethod
+    def rating_class_etr(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(roi_bgr, cls.ETR_HSV_MIN, cls.ETR_HSV_MAX)
+
+    @classmethod
+    def max_recall(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(
+            roi_bgr, cls.MAX_RECALL_HSV_MIN, cls.MAX_RECALL_HSV_MAX
+        )
+
+    @classmethod
+    def clear_status_track_lost(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(
+            roi_bgr, cls.TRACK_LOST_HSV_MIN, cls.TRACK_LOST_HSV_MAX
+        )
+
+    @classmethod
+    def clear_status_track_complete(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(
+            roi_bgr, cls.TRACK_COMPLETE_HSV_MIN, cls.TRACK_COMPLETE_HSV_MAX
+        )
+
+    @classmethod
+    def clear_status_full_recall(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(
+            roi_bgr, cls.FULL_RECALL_HSV_MIN, cls.FULL_RECALL_HSV_MAX
+        )
+
+    @classmethod
+    def clear_status_pure_memory(cls, roi_bgr: Mat) -> Mat:
+        return cls.mask_bgr_in_hsv(
+            roi_bgr, cls.PURE_MEMORY_HSV_MIN, cls.PURE_MEMORY_HSV_MAX
+        )

src/arcaea_offline_ocr/scenarios/device/masker/base.py

@@ -0,0 +1,61 @@
+from abc import ABC, abstractmethod
+
+from arcaea_offline_ocr.types import Mat
+
+
+class DeviceRoisMasker(ABC):
+    @classmethod
+    @abstractmethod
+    def pure(cls, roi_bgr: Mat) -> Mat: ...
+
+    @classmethod
+    @abstractmethod
+    def far(cls, roi_bgr: Mat) -> Mat: ...
+
+    @classmethod
+    @abstractmethod
+    def lost(cls, roi_bgr: Mat) -> Mat: ...
+
+    @classmethod
+    @abstractmethod
+    def score(cls, roi_bgr: Mat) -> Mat: ...
+
+    @classmethod
+    @abstractmethod
+    def rating_class_pst(cls, roi_bgr: Mat) -> Mat: ...
+
+    @classmethod
+    @abstractmethod
+    def rating_class_prs(cls, roi_bgr: Mat) -> Mat: ...
+
+    @classmethod
+    @abstractmethod
+    def rating_class_ftr(cls, roi_bgr: Mat) -> Mat: ...
+
+    @classmethod
+    @abstractmethod
+    def rating_class_byd(cls, roi_bgr: Mat) -> Mat: ...
+
+    @classmethod
+    @abstractmethod
+    def rating_class_etr(cls, roi_bgr: Mat) -> Mat: ...
+
+    @classmethod
+    @abstractmethod
+    def max_recall(cls, roi_bgr: Mat) -> Mat: ...
+
+    @classmethod
+    @abstractmethod
+    def clear_status_track_lost(cls, roi_bgr: Mat) -> Mat: ...
+
+    @classmethod
+    @abstractmethod
+    def clear_status_track_complete(cls, roi_bgr: Mat) -> Mat: ...
+
+    @classmethod
+    @abstractmethod
+    def clear_status_full_recall(cls, roi_bgr: Mat) -> Mat: ...
+
+    @classmethod
+    @abstractmethod
+    def clear_status_pure_memory(cls, roi_bgr: Mat) -> Mat: ...

src/arcaea_offline_ocr/scenarios/device/rois/__init__.py

@@ -0,0 +1,9 @@
+from .auto import DeviceRoisAuto, DeviceRoisAutoT1, DeviceRoisAutoT2
+from .base import DeviceRois
+
+__all__ = [
+    "DeviceRois",
+    "DeviceRoisAuto",
+    "DeviceRoisAutoT1",
+    "DeviceRoisAutoT2",
+]

src/arcaea_offline_ocr/scenarios/device/rois/auto.py

@@ -0,0 +1,255 @@
+from arcaea_offline_ocr.types import XYWHRect
+
+from .base import DeviceRois
+
+
+class DeviceRoisAuto(DeviceRois):
+    def __init__(self, w: int, h: int):
+        self.w = w
+        self.h = h
+
+
+class DeviceRoisAutoT1(DeviceRoisAuto):
+    @property
+    def factor(self):
+        return (
+            ((self.w / 16) * 9) / 720 if (self.w / self.h) < (16 / 9) else self.h / 720
+        )
+
+    @property
+    def w_mid(self):
+        return self.w / 2
+
+    @property
+    def h_mid(self):
+        return self.h / 2
+
+    @property
+    def top_bar(self):
+        return (0, 0, self.w, 50 * self.factor)
+
+    @property
+    def layout_area_h_mid(self):
+        return self.h / 2 + self.top_bar[3]
+
+    @property
+    def pfl_left_from_w_mid(self):
+        return 5 * self.factor
+
+    @property
+    def pfl_x(self):
+        return self.w_mid + self.pfl_left_from_w_mid
+
+    @property
+    def pfl_w(self):
+        return 76 * self.factor
+
+    @property
+    def pfl_h(self):
+        return 26 * self.factor
+
+    @property
+    def pure(self):
+        return XYWHRect(
+            self.pfl_x,
+            self.layout_area_h_mid + 110 * self.factor,
+            self.pfl_w,
+            self.pfl_h,
+        )
+
+    @property
+    def far(self):
+        return XYWHRect(
+            self.pfl_x,
+            self.pure[1] + self.pure[3] + 12 * self.factor,
+            self.pfl_w,
+            self.pfl_h,
+        )
+
+    @property
+    def lost(self):
+        return XYWHRect(
+            self.pfl_x,
+            self.far[1] + self.far[3] + 10 * self.factor,
+            self.pfl_w,
+            self.pfl_h,
+        )
+
+    @property
+    def score(self):
+        w = 280 * self.factor
+        h = 45 * self.factor
+        return XYWHRect(
+            self.w_mid - w / 2,
+            self.layout_area_h_mid - 75 * self.factor - h,
+            w,
+            h,
+        )
+
+    @property
+    def rating_class(self):
+        return XYWHRect(
+            self.w_mid - 610 * self.factor,
+            self.layout_area_h_mid - 180 * self.factor,
+            265 * self.factor,
+            35 * self.factor,
+        )
+
+    @property
+    def max_recall(self):
+        return XYWHRect(
+            self.w_mid - 465 * self.factor,
+            self.layout_area_h_mid - 215 * self.factor,
+            150 * self.factor,
+            35 * self.factor,
+        )
+
+    @property
+    def jacket(self):
+        return XYWHRect(
+            self.w_mid - 610 * self.factor,
+            self.layout_area_h_mid - 143 * self.factor,
+            375 * self.factor,
+            375 * self.factor,
+        )
+
+    @property
+    def clear_status(self):
+        w = 550 * self.factor
+        h = 60 * self.factor
+        return XYWHRect(
+            self.w_mid - w / 2,
+            self.layout_area_h_mid - 155 * self.factor - h,
+            w * 0.4,
+            h,
+        )
+
+    @property
+    def partner_icon(self):
+        w = 90 * self.factor
+        h = 75 * self.factor
+        return XYWHRect(self.w_mid - w / 2, 0, w, h)
+
+
+class DeviceRoisAutoT2(DeviceRoisAuto):
+    @property
+    def factor(self):
+        return (
+            ((self.w / 16) * 9) / 1080
+            if (self.w / self.h) < (16 / 9)
+            else self.h / 1080
+        )
+
+    @property
+    def w_mid(self):
+        return self.w / 2
+
+    @property
+    def h_mid(self):
+        return self.h / 2
+
+    @property
+    def top_bar(self):
+        return (0, 0, self.w, 75 * self.factor)
+
+    @property
+    def layout_area_h_mid(self):
+        return self.h / 2 + self.top_bar[3]
+
+    @property
+    def pfl_mid_from_w_mid(self):
+        return 60 * self.factor
+
+    @property
+    def pfl_x(self):
+        return self.w_mid + 10 * self.factor
+
+    @property
+    def pfl_w(self):
+        return 100 * self.factor
+
+    @property
+    def pfl_h(self):
+        return 24 * self.factor
+
+    @property
+    def pure(self):
+        return XYWHRect(
+            self.pfl_x,
+            self.layout_area_h_mid + 175 * self.factor,
+            self.pfl_w,
+            self.pfl_h,
+        )
+
+    @property
+    def far(self):
+        return XYWHRect(
+            self.pfl_x,
+            self.pure[1] + self.pure[3] + 30 * self.factor,
+            self.pfl_w,
+            self.pfl_h,
+        )
+
+    @property
+    def lost(self):
+        return XYWHRect(
+            self.pfl_x,
+            self.far[1] + self.far[3] + 35 * self.factor,
+            self.pfl_w,
+            self.pfl_h,
+        )
+
+    @property
+    def score(self):
+        w = 420 * self.factor
+        h = 70 * self.factor
+        return XYWHRect(
+            self.w_mid - w / 2,
+            self.layout_area_h_mid - 110 * self.factor - h,
+            w,
+            h,
+        )
+
+    @property
+    def rating_class(self):
+        return XYWHRect(
+            max(0, self.w_mid - 965 * self.factor),
+            self.layout_area_h_mid - 330 * self.factor,
+            350 * self.factor,
+            110 * self.factor,
+        )
+
+    @property
+    def max_recall(self):
+        return XYWHRect(
+            self.w_mid - 625 * self.factor,
+            self.layout_area_h_mid - 275 * self.factor,
+            150 * self.factor,
+            50 * self.factor,
+        )
+
+    @property
+    def jacket(self):
+        return XYWHRect(
+            self.w_mid - 915 * self.factor,
+            self.layout_area_h_mid - 215 * self.factor,
+            565 * self.factor,
+            565 * self.factor,
+        )
+
+    @property
+    def clear_status(self):
+        w = 825 * self.factor
+        h = 90 * self.factor
+        return XYWHRect(
+            self.w_mid - w / 2,
+            self.layout_area_h_mid - 235 * self.factor - h,
+            w * 0.4,
+            h,
+        )
+
+    @property
+    def partner_icon(self):
+        w = 135 * self.factor
+        h = 110 * self.factor
+        return XYWHRect(self.w_mid - w / 2, 0, w, h)

src/arcaea_offline_ocr/scenarios/device/rois/base.py

@@ -0,0 +1,33 @@
+from abc import ABC, abstractmethod
+
+from arcaea_offline_ocr.types import XYWHRect
+
+
+class DeviceRois(ABC):
+    @property
+    @abstractmethod
+    def pure(self) -> XYWHRect: ...
+    @property
+    @abstractmethod
+    def far(self) -> XYWHRect: ...
+    @property
+    @abstractmethod
+    def lost(self) -> XYWHRect: ...
+    @property
+    @abstractmethod
+    def score(self) -> XYWHRect: ...
+    @property
+    @abstractmethod
+    def rating_class(self) -> XYWHRect: ...
+    @property
+    @abstractmethod
+    def max_recall(self) -> XYWHRect: ...
+    @property
+    @abstractmethod
+    def jacket(self) -> XYWHRect: ...
+    @property
+    @abstractmethod
+    def clear_status(self) -> XYWHRect: ...
+    @property
+    @abstractmethod
+    def partner_icon(self) -> XYWHRect: ...

src/arcaea_offline_ocr/sift_db.py

@@ -1,110 +0,0 @@
-import io
-import sqlite3
-from gzip import GzipFile
-from typing import Tuple
-
-import cv2
-import numpy as np
-
-from .types import Mat
-
-
-class SIFTDatabase:
-    def __init__(self, db_path: str, load: bool = True):
-        self.__db_path = db_path
-        self.__tags = []
-        self.__descriptors = []
-        self.__size = None
-
-        self.__sift = cv2.SIFT_create()
-        self.__bf_matcher = cv2.BFMatcher()
-
-        if load:
-            self.load_db()
-
-    @property
-    def db_path(self):
-        return self.__db_path
-
-    @db_path.setter
-    def db_path(self, value):
-        self.__db_path = value
-
-    @property
-    def tags(self):
-        return self.__tags
-
-    @property
-    def descriptors(self):
-        return self.__descriptors
-
-    @property
-    def size(self):
-        return self.__size
-
-    @size.setter
-    def size(self, value: Tuple[int, int]):
-        self.__size = value
-
-    @property
-    def sift(self):
-        return self.__sift
-
-    @property
-    def bf_matcher(self):
-        return self.__bf_matcher
-
-    def load_db(self):
-        conn = sqlite3.connect(self.db_path)
-        with conn:
-            cursor = conn.cursor()
-
-            size_str = cursor.execute(
-                "SELECT value FROM properties WHERE id = 'size'"
-            ).fetchone()[0]
-            sizr_str_arr = size_str.split(", ")
-            self.size = tuple(int(s) for s in sizr_str_arr)
-            tag__descriptors_bytes = cursor.execute(
-                "SELECT tag, descriptors FROM sift"
-            ).fetchall()
-
-            gzipped = int(
-                cursor.execute(
-                    "SELECT value FROM properties WHERE id = 'gzip'"
-                ).fetchone()[0]
-            )
-            for tag, descriptor_bytes in tag__descriptors_bytes:
-                buffer = io.BytesIO(descriptor_bytes)
-                self.tags.append(tag)
-                if gzipped == 0:
-                    self.descriptors.append(np.load(buffer))
-                else:
-                    gzipped_buffer = GzipFile(None, "rb", fileobj=buffer)
-                    self.descriptors.append(np.load(gzipped_buffer))
-
-    def lookup_img(
-        self,
-        __img: Mat,
-        *,
-        sift=None,
-        bf=None,
-    ) -> Tuple[str, float]:
-        sift = sift or self.sift
-        bf = bf or self.bf_matcher
-
-        img = __img.copy()
-        if self.size is not None:
-            img = cv2.resize(img, self.size)
-        _, descriptors = sift.detectAndCompute(img, None)
-
-        good_results = []
-        for des in self.descriptors:
-            matches = bf.knnMatch(descriptors, des, k=2)
-            good = sum(m.distance < 0.75 * n.distance for m, n in matches)
-            good_results.append(good)
-        best_match_index = max(enumerate(good_results), key=lambda i: i[1])[0]
-
-        return (
-            self.tags[best_match_index],
-            good_results[best_match_index] / len(descriptors),
-        )

src/arcaea_offline_ocr/types.py

@@ -1,42 +1,42 @@
-from collections.abc import Iterable
+from math import floor
-from typing import Any, NamedTuple, Protocol, Tuple, Union
+from typing import Callable, NamedTuple, Union
 
 import numpy as np
 
-# from pylance
+Mat = np.ndarray
-Mat = np.ndarray[int, np.dtype[np.generic]]
+
+_IntOrFloat = Union[int, float]
 
 
 class XYWHRect(NamedTuple):
-    x: int
+    x: _IntOrFloat
-    y: int
+    y: _IntOrFloat
-    w: int
+    w: _IntOrFloat
-    h: int
+    h: _IntOrFloat
 
-    def __add__(self, other: Union["XYWHRect", Tuple[int, int, int, int]]):
+    def _to_int(self, func: Callable[[_IntOrFloat], int]):
-        if not isinstance(other, Iterable) or len(other) != 4:
+        return (func(self.x), func(self.y), func(self.w), func(self.h))
-            raise ValueError()
+
+    def rounded(self):
+        return self._to_int(round)
+
+    def floored(self):
+        return self._to_int(floor)
+
+    def __add__(self, other):
+        if not isinstance(other, (list, tuple)) or len(other) != 4:
+            raise TypeError()
 
         return self.__class__(*[a + b for a, b in zip(self, other)])
 
-    def __sub__(self, other: Union["XYWHRect", Tuple[int, int, int, int]]):
+    def __sub__(self, other):
-        if not isinstance(other, Iterable) or len(other) != 4:
+        if not isinstance(other, (list, tuple)) or len(other) != 4:
-            raise ValueError()
+            raise TypeError()
 
         return self.__class__(*[a - b for a, b in zip(self, other)])
 
+    def __mul__(self, other):
+        if not isinstance(other, (int, float)):
+            raise TypeError()
 
-class cv2_ml_StatModel(Protocol):
+        return self.__class__(*[v * other for v in self])
-    def predict(self, samples: np.ndarray, results: np.ndarray, flags: int = 0):
-        ...
-
-    def train(self, samples: np.ndarray, layout: int, responses: np.ndarray):
-        ...
-
-
-class cv2_ml_KNearest(cv2_ml_StatModel, Protocol):
-    def findNearest(
-        self, samples: np.ndarray, k: int
-    ) -> Tuple[Any, np.ndarray, np.ndarray, np.ndarray]:
-        """cv.ml.KNearest.findNearest(samples, k[, results[, neighborResponses[, dist]]]) -> retval, results, neighborResponses, dist"""
-        ...

src/arcaea_offline_ocr/utils.py

@@ -1,70 +1,10 @@
-import io
-from collections.abc import Iterable
-from typing import Callable, Tuple, TypeVar, Union, overload
-
 import cv2
 import numpy as np
-from PIL import Image, ImageCms
-
-from .types import Mat, XYWHRect
 
 __all__ = ["imread_unicode"]
 
 
-def imread_unicode(filepath: str, flags: int = cv2.IMREAD_UNCHANGED) -> Mat:
+def imread_unicode(filepath: str, flags: int = cv2.IMREAD_UNCHANGED):
     # https://stackoverflow.com/a/57872297/16484891
     # CC BY-SA 4.0
     return cv2.imdecode(np.fromfile(filepath, dtype=np.uint8), flags)
-
-
-def construct_int_xywh_rect(
-    rect: XYWHRect, func: Callable[[Union[int, float]], int] = round
-):
-    return XYWHRect(*[func(num) for num in rect])
-
-
-@overload
-def apply_factor(item: int, factor: float) -> float:
-    ...
-
-
-@overload
-def apply_factor(item: float, factor: float) -> float:
-    ...
-
-
-T = TypeVar("T", bound=Iterable)
-
-
-@overload
-def apply_factor(item: T, factor: float) -> T:
-    ...
-
-
-def apply_factor(item, factor: float):
-    if isinstance(item, (int, float)):
-        return item * factor
-    elif isinstance(item, Iterable):
-        return item.__class__([i * factor for i in item])
-
-
-def convert_to_srgb(pil_img: Image.Image):
-    """
-    Convert PIL image to sRGB color space (if possible)
-    and save the converted file.
-
-    https://stackoverflow.com/a/65667797/16484891
-
-    CC BY-SA 4.0
-    """
-    icc = pil_img.info.get("icc_profile", "")
-    icc_conv = ""
-
-    if icc:
-        io_handle = io.BytesIO(icc)  # virtual file
-        src_profile = ImageCms.ImageCmsProfile(io_handle)
-        dst_profile = ImageCms.createProfile("sRGB")
-        img_conv = ImageCms.profileToProfile(pil_img, src_profile, dst_profile)
-        icc_conv = img_conv.info.get("icc_profile", "")
-
-    return img_conv if icc != icc_conv else pil_img