Actually install maven

Previous commit had logging compile, but would not run properly due to
improperly formatted log information in logback.xml This has been fixed.

.forgejo/workflows/build.yaml

@@ -0,0 +1,13 @@
+name: Java CI
+on: [push]
+
+jobs:
+  build:
+    runs-on: docker
+    steps:
+      - name: Checkout project
+        uses: actions/checkout@v3
+      - name: Set up JDK11
+        run: apt update && apt install -y maven
+      - name: Build with Maven
+        run: mvn -Djavacpp.platform=linux-arm64 clean package

.github/workflows/maven-publish.yml

@@ -1,34 +0,0 @@
-# This workflow will build a package using Maven and then publish it to GitHub packages when a release is created
-# For more information see: https://github.com/actions/setup-java/blob/main/docs/advanced-usage.md#apache-maven-with-a-settings-path
-
-name: Maven Package
-
-on:
-  release:
-    types: [created]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-
-    steps:
-    - uses: actions/checkout@v3
-    - name: Set up JDK 11
-      uses: actions/setup-java@v3
-      with:
-        java-version: '11'
-        distribution: 'temurin'
-        server-id: github # Value of the distributionManagement/repository/id field of the pom.xml
-        settings-path: ${{ github.workspace }} # location for the settings.xml file
-
-    - name: Build with Maven
-      run: mvn -B package --file pom.xml
-
-    - name: Publish to GitHub Packages Apache Maven
-      run: mvn deploy -s $GITHUB_WORKSPACE/settings.xml
-      env:
-        GITHUB_TOKEN: ${{ github.token }}

LICENSE

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

README.md

@@ -35,6 +35,8 @@ To further develop this software, or to compile it from source, the following is
 	- A Java-compatible IDE
 	- Maven
 	- OpenJDK11
+	- .NET 6.0
+		- (Optional, for complete dependency checking)
 
 OpenJDK11 is explicitly required, as it is the only currently available Java development platform compatible with [Pi4J](https://pi4j.com/getting-started/). According to the [documentation for Pi4J](https://pi4j.com/getting-started/developing-on-a-remote-pc/), development on a Raspberry Pi is possible, but given this project's build time (as of 4.0.0-rc3, 2-5 minutes on a Baxter-distributed device, before documentation generation), it is recommended to build on x86-64, and copy to the compiled JAR to the Pi. As such, this repository has been designed with this development model in mind. If you are intending on compiling on a Pi, please see the above-linked documentation to see what should be modified in your local `pom.xml` file.
 

dependency-reduced-pom.xml

@@ -4,7 +4,7 @@
   <groupId>org.baxter.disco</groupId>
   <artifactId>ocr</artifactId>
   <name>Disco OCR Accuracy Over Life Testing</name>
-  <version>4.3.8</version>
+  <version>5.0.0-alpha.2</version>
   <description>Testing Discos for long-term accuracy, using automated optical character recognition.</description>
   <organization>
     <name>Baxter International</name>
@@ -95,9 +95,6 @@
       <plugin>
         <artifactId>maven-javadoc-plugin</artifactId>
         <version>3.4.1</version>
-        <configuration>
-          <show>private</show>
-        </configuration>
       </plugin>
     </plugins>
   </reporting>

pom.xml

@@ -3,7 +3,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>org.baxter.disco</groupId>
     <artifactId>ocr</artifactId>
-    <version>4.3.8</version>
+    <version>5.0.0-alpha.2</version>
     <packaging>jar</packaging>
     <name>Disco OCR Accuracy Over Life Testing</name>
     <description>Testing Discos for long-term accuracy, using automated optical character recognition.</description>
@@ -34,6 +34,19 @@
     </properties>
 
     <dependencies>
+
+	<!-- Logging libraries -->
+	<dependency>
+		<groupId>org.slf4j</groupId>
+		<artifactId>slf4j-api</artifactId>
+		<version>2.0.7</version>
+	</dependency>
+	<dependency>
+		<groupId>ch.qos.logback</groupId>
+		<artifactId>logback-classic</artifactId>
+		<version>1.4.6</version>
+	</dependency>
+
         <!-- JUnit Testing -->
         <dependency>
             <groupId>org.junit.jupiter</groupId>
@@ -65,13 +78,6 @@
             <version>${beanutils.version}</version>
         </dependency>
 
-        <!-- Edit Excel document via Apache POI/poi-ooxml -->
-        <dependency>
-            <groupId>org.apache.poi</groupId>
-            <artifactId>poi-ooxml</artifactId>
-            <version>${poi.version}</version>
-        </dependency>
-
         <!-- include Pi4J Core -->
         <dependency>
             <groupId>com.pi4j</groupId>
@@ -192,9 +198,9 @@
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-javadoc-plugin</artifactId>
                 <version>3.4.1</version>
-                <configuration>
+                <!--<configuration>
                     <show>private</show>
-                </configuration>
+                </configuration>-->
             </plugin>
         </plugins>
     </reporting>

runScript.sh

@@ -1,2 +1,2 @@
 #! /usr/bin/env sh
-sudo java -jar discoTesting-4.3.8.jar 2>/dev/null
+sudo java -jar discoTesting-4.3.9.jar 2>/dev/null

src/main/java/module-info.java

@@ -6,18 +6,19 @@ module org.baxter.disco.ocr {
     //requires javafx.fxml;
     //requires javafx.controls;
     requires javafx.swing;
-    requires org.apache.poi.poi;
+    //requires org.apache.poi.poi;
     requires org.apache.commons.configuration2;
-    requires org.apache.xmlbeans;
+    //requires org.apache.xmlbeans;
     requires org.bytedeco.tesseract;
     requires org.bytedeco.leptonica;
     requires org.bytedeco.opencv;
     requires org.bytedeco.javacpp;
     //requires javafx.graphics;
-    requires org.apache.poi.ooxml;
-    requires org.apache.poi.ooxml.schemas;
-    requires org.apache.commons.io;
+    //requires org.apache.poi.ooxml;
+    //requires org.apache.poi.ooxml.schemas;
+    //requires org.apache.commons.io;
     requires org.apache.commons.lang3;
+    requires org.slf4j;
 
     requires org.bytedeco.javacv.platform;
     //requires java.desktop;
@@ -25,6 +26,7 @@ module org.baxter.disco.ocr {
     uses com.pi4j.extension.Extension;
     uses com.pi4j.provider.Provider;
 
+
     // allow access to classes in the following namespaces for Pi4J annotation processing
     opens org.baxter.disco.ocr to com.pi4j;
 

src/main/java/org/baxter/disco/ocr/Cli.java

@@ -1,14 +1,18 @@
 package org.baxter.disco.ocr;
 
+import java.lang.invoke.MethodHandles;
+
 //Standard imports
 import java.io.File;
-import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.HashSet;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Scanner;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantLock;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * CLI for the Fixture.
@@ -18,14 +22,14 @@ import java.util.concurrent.locks.ReentrantLock;
  * classes).
  *
  * @author Blizzard Finnegan
- * @version 1.7.1, 10 Mar. 2023
+ * @version 1.10.0, 20 Mar. 2023
  */
 public class Cli
 {
     /**
      * Complete build version number
      */
-    private static final String version = "4.3.8";
+    private static final String version = "5.0.0-alpha.2";
 
     /**
      * Currently saved iteration count.
@@ -66,17 +70,17 @@ public class Cli
     private static final int cameraMenuOptionCount = 7;
 
     /**
-     * Lock object, used for temporary interruption of {@link #runTests()}
+     * Class-level logger
      */
-    public static final Lock LOCK = new ReentrantLock();
+    private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
 
 
     static
     {
-        ErrorLogging.logError("========================");
-        ErrorLogging.logError("Accuracy Over Life Test");
-        ErrorLogging.logError("Version: " + version);
-        ErrorLogging.logError("========================");
+        logger.info("========================");
+        logger.info("Accuracy Over Life Test");
+        logger.info("Version: " + version);
+        logger.info("========================");
     }
 
     public static void main(String[] args)
@@ -88,8 +92,8 @@ public class Cli
 
             int userInput = 0;
 
-            ErrorLogging.logError("Calibrating motor movement. ");
-            ErrorLogging.logError("The piston will fire momentarily when the motor calibration is complete.");
+            logger.info("Calibrating motor movement. ");
+            logger.info("The piston will fire momentarily when the motor calibration is complete.");
             
             boolean testedGPIO = false;
             do
@@ -97,21 +101,23 @@ public class Cli
                 try
                 {
                     MovementFacade.init();
-                    ErrorLogging.logError("Motor movement successfully calibrated!");
+                    logger.info("Motor movement successfully calibrated!");
                     testedGPIO = true;
                     safeGPIO = true;
                 }
                 catch(Exception e)
                 {
-                    ErrorLogging.logError(e);
-                    ErrorLogging.logError("GPIO initialisation error! Please check GPIO connections.");
+		    String errorMessage = "GPIO initialisation error! Please check GPIO connection, and "+
+			    "ensure that the PWM is set high enough so that the fixture can hit the lower limit "+
+			    "switch within 3 seconds.";
+		    logger.error(errorMessage);
                     println("");
                     prompt("Press enter to try again."); 
                     String userInputString = inputScanner.nextLine();
                     if(userInputString.length() > 0)
                     {
                         testedGPIO = userInputString.contains("override");
-                        ErrorLogging.logError("DEBUG: WARNING! - User override of GPIO check.");
+                        logger.warn("User override of GPIO check.");
                     }
                 }
             }while(!testedGPIO);
@@ -143,11 +149,11 @@ public class Cli
                             String input = inputScanner.nextLine().toLowerCase().trim();
                             if( input.isBlank() || input.charAt(0) != 'y' ) break;
                             else 
-                                ErrorLogging.logError("DEBUG: Potential for error: Un-initialised cameras.");
+                                logger.warn("Potential for error: Un-initialised cameras.");
                         }
 
                         serialsSet = true;
-                        for(String cameraName : OpenCVFacade.getCameraNames())
+                        for(String cameraName : ImageFacade.getCameraNames())
                         {
                             if(ConfigFacade.getValue(cameraName,ConfigProperties.ACTIVE) != 0 && 
                                ConfigFacade.getSerial(cameraName) == null )
@@ -159,7 +165,7 @@ public class Cli
                             String input = inputScanner.nextLine().toLowerCase().trim();
                             if( input.isBlank() || input.charAt(0) != 'y' ) break;
                             else
-                                ErrorLogging.logError("DEBUG: Potential for error: Un-initialised DUT Serial numbers.");
+                                logger.warn("Potential for error: Un-initialised DUT Serial numbers.");
                         }
 
                         runTests();
@@ -168,7 +174,7 @@ public class Cli
                         printHelp();
                         break;
                     case 8:
-                        ErrorLogging.logError("DEBUG: User requested manual exit of program. Cleanly exiting...");
+                        logger.warn("User requested manual exit of program. Cleanly exiting...");
                         break;
                     default:
                         //Input handling already done by inputFiltering()
@@ -180,8 +186,8 @@ public class Cli
         //If anything ever goes wrong, catch the error and exit
         catch(Exception e) 
         { 
-            ErrorLogging.logError(e); 
-            ErrorLogging.logError("ERROR CAUGHT - CLOSING PROGRAM.");
+            logger.error("ERROR CAUGHT - CLOSING PROGRAM.");
+            logger.trace("Error caught: ",e); 
         }
         //Always return the fixture back to the upper limit switch, close all open connections safely
         finally
@@ -217,7 +223,7 @@ public class Cli
      */
     private static void printHelp()
     {
-        ErrorLogging.logError("DEBUG: User asked for help at main menu.");
+        logger.debug("User asked for help at main menu.");
         println("\n\n");
         println("========================================");
         println("Explanations:");
@@ -378,7 +384,7 @@ public class Cli
      */
     private static void printCameraConfigHelpMenu()
     {
-        ErrorLogging.logError("DEBUG: User asked for help at camera config menu.");
+        logger.debug("User asked for help at camera config menu.");
         println("\n\n");
         println("============================================================");
         println("Camera Config Menu options:");
@@ -420,8 +426,8 @@ public class Cli
      */
     private static void configureCameras()
     {
-        ErrorLogging.logError("DEBUG: Configuing cameras...");
-        List<String> cameraList = new ArrayList<>(OpenCVFacade.getCameraNames());
+        logger.debug("Configuing cameras...");
+        List<String> cameraList = new ArrayList<>(ImageFacade.getCameraNames());
 
         //Always wake the camera, to ensure that the image is useful
         if(safeGPIO) MovementFacade.iterationMovement(true);
@@ -450,13 +456,13 @@ public class Cli
                 {
                     //Press button twice, to make sure the DUT is awake
                     MovementFacade.pressButton();
-                    try{ Thread.sleep(2000); } catch(Exception e){ ErrorLogging.logError(e); }
+                    try{ Thread.sleep(2000); } catch(Exception e){ logger.error("Error caught!\nError: ",e); }
                     MovementFacade.pressButton();
-                    try{ Thread.sleep(2000); } catch(Exception e){ ErrorLogging.logError(e); }
+                    try{ Thread.sleep(2000); } catch(Exception e){ logger.error("Error caught!\nError: ",e); }
                 }
 
-                File image = OpenCVFacade.showImage(cameraName);
-                tesseractValue = TesseractFacade.imageToDouble(image);
+                File image = ImageFacade.showImage(cameraName);
+                tesseractValue = ImageFacade.imageToDouble(image);
 
                 ConfigProperties modifiedProperty = null;
                 do
@@ -501,7 +507,7 @@ public class Cli
                 }
 
                 else if(modifiedProperty == ConfigProperties.CROP_X)
-                { OpenCVFacade.setCrop(cameraName); }
+                { ImageFacade.setCrop(cameraName); }
 
                 else if(modifiedProperty == ConfigProperties.COMPOSITE_FRAMES ||
                         modifiedProperty == ConfigProperties.THRESHOLD_VALUE)
@@ -532,8 +538,8 @@ public class Cli
      */
     private static void setDUTSerials()
     {
-        ErrorLogging.logError("DEBUG: Setting DUT serials...");
-        List<String> cameraList = new ArrayList<>(OpenCVFacade.getCameraNames());
+        logger.debug("Setting DUT serials...");
+        List<String> cameraList = new ArrayList<>(ImageFacade.getCameraNames());
         do
         {
             printSerialMenu(cameraList);
@@ -570,7 +576,7 @@ public class Cli
             input = (int)inputFiltering(inputScanner.nextLine());
         } while(input == -1);
         iterationCount = input;
-        ErrorLogging.logError("DEBUG: Iteration count modified! Iteration count is now: " + iterationCount);
+        logger.trace("Iteration count modified! Iteration count is now: " + iterationCount);
     }
 
     /**
@@ -578,8 +584,8 @@ public class Cli
      */
     private static void setActiveCameras()
     {
-        ErrorLogging.logError("DEBUG: User modified active cameras.");
-        List<String> cameraList = new ArrayList<>(OpenCVFacade.getCameraNames());
+        logger.trace("User modified active cameras.");
+        List<String> cameraList = new ArrayList<>(ImageFacade.getCameraNames());
 
         do
         {
@@ -602,13 +608,13 @@ public class Cli
             ConfigFacade.setValue(cameraName,ConfigProperties.ACTIVE,newValue);
 
         } while(true);
-        ErrorLogging.logError("DEBUG: Currently active cameras:");
-        for(String camera : OpenCVFacade.getCameraNames())
+        logger.debug("Currently active cameras:");
+        for(String camera : ImageFacade.getCameraNames())
         {
             if(ConfigFacade.getValue(camera,ConfigProperties.ACTIVE) != 0)
-                ErrorLogging.logError("DEBUG: - " + camera);
+                logger.debug("- " + camera);
         }
-        ErrorLogging.logError("DEBUG:");
+        logger.debug("");
     }
 
     /**
@@ -617,7 +623,7 @@ public class Cli
     private static void runTests()
     {
         println("====================================");
-        ErrorLogging.logError("Initialising tests...");
+        logger.info("Initialising tests...");
 
         //Bring the iteration count into the function as a final variable
         //useful for multithreading, which isn't necessary in CLI
@@ -626,94 +632,103 @@ public class Cli
         //Hide legacy functionality
         boolean prime = false; 
 
-        List<String> cameraList = new ArrayList<>();
-        for(String cameraName : OpenCVFacade.getCameraNames())
+        Map<String,String> cameraSerialList = new HashMap<>();
+        for(String cameraName : ImageFacade.getCameraNames())
         {
             prime = (ConfigFacade.getValue(cameraName,ConfigProperties.PRIME) != 0) || prime; 
 
             if(ConfigFacade.getValue(cameraName,ConfigProperties.ACTIVE) != 0)
-                cameraList.add(cameraName);
+                cameraSerialList.put(cameraName,ConfigFacade.getSerial(cameraName));
         }
 
-        DataSaving.initWorkbook(ConfigFacade.getOutputSaveLocation(),cameraList.size());
+	if(cameraSerialList.size() == 0)
+	{
+		logger.error("No valid cameras! Tests cannot be run! Please ensure that at least one camera is active before continuing.");
+		return;
+	}
 
         //Wake the device, then wait to ensure they're awake before continuing
-        ErrorLogging.logError("DEBUG: Waking devices...");
+        logger.info("Waking devices...");
         if(safeGPIO) 
         {
             MovementFacade.pressButton();
-            try{ Thread.sleep(2000); } catch(Exception e){ ErrorLogging.logError(e); }
+            try{ Thread.sleep(2000); } catch(Exception e){ logger.error("Error caught!\nError: ",e); }
         }
 
-        Map<File,Double> resultMap = new HashMap<>();
-        Map<String,File> cameraToFile = new HashMap<>();
+        //final Map<String,String> serials = ConfigFacade.getSerials();
 
-        //Initialise cameraToFile, so keys don't shuffle.
-        for(String cameraName : cameraList)
-        {
-            cameraToFile.put(cameraName,new File("/dev/null"));
-        }
+        logger.info("Starting tests...");
 
-        ErrorLogging.logError("DEBUG: Starting tests...");
+        State state = new State(ConfigFacade.getSerials());
+
+        
+        //final LinkedBlockingQueue<Cycle> dataEntryQueue = new LinkedBlockingQueue<>();
+
+        //Thread writeThread = new Thread( () -> {
+        //    logger.debug("Starting write thread...");
+        //    while(true)
+        //    {
+        //        Cycle cycle = null;
+
+        //        try{ cycle = dataEntryQueue.take(); }
+        //        catch(Exception e){ logger.error("Error caught!\nError: ",e); }
+
+        //        if(cycle.getcycleNumber() == -1) break;
+
+        //        DataSaving.writeValues(state);
+        //    }
+        //    logger.debug("Exiting write thread.");
+        //});
+
+        //writeThread.start();
 
-        //All portions of the test check with the GPIO Run/Pause switch before 
-        //continuing, using the Lock object.
         for(int i = 0; i < localIterations; i++)
         {
+            //Cycle cycle = new Cycle(i);
             println("");
-            ErrorLogging.logError("====================================");
-            ErrorLogging.logError("Starting iteration " + (i+1) + " of " + localIterations + "...");
+            logger.info("====================================");
+            logger.info("Starting iteration " + (i+1) + " of " + localIterations + "...");
 
             //Loop the below if errors are created errors include 
             // - reading of LO on the DUT (Tesseract reads this generally as 1.0 or 117.0)
-            // - Failed reading from the DUT (Tesseract fails this reading, and TesseractFacade.imageToDouble() returns Double.NEGATIVE_INFINITY)
+            // - Failed reading from the DUT (Tesseract fails this reading, and ImageFacade.imageToDouble() returns Double.NEGATIVE_INFINITY)
             boolean fail = false;
             do
             {
+                HashSet<Double> values = new HashSet<>();
                 fail = false;
                 if(safeGPIO)
                 {
-                    while(!LOCK.tryLock()) {}
                     MovementFacade.iterationMovement(prime);
-                    LOCK.unlock();
 
                     //Wait for the DUT to display an image
-                    try{ Thread.sleep(2000); } catch(Exception e){ ErrorLogging.logError(e); }
+                    try{ Thread.sleep(2000); } catch(Exception e){ logger.error("Error caught!\nError: ",e); }
                 }
 
-                for(String cameraName : cameraList)
+                for(String cameraName : cameraSerialList.keySet())
                 {
-                    while(!LOCK.tryLock()) {}
-                    File file = OpenCVFacade.completeProcess(cameraName);
-                    LOCK.unlock();
-
-                    while(!LOCK.tryLock()) {}
-                    cameraToFile.replace(cameraName,file);
-                    LOCK.unlock();
+                    Thread cameraThread = new Thread(() -> {
+                        File resultFile = ImageFacade.completeProcess(cameraName);
+                        double result = ImageFacade.imageToDouble(resultFile);
+                        values.add(result);
+                        state.addIteration(cameraSerialList.get(cameraName),result);
+                    });
+                    cameraThread.start();
+                    try{ cameraThread.join(); } catch(Exception e){ logger.error("Error caught!\nError: ",e); }
                 }
 
-                for(String cameraName : cameraList)
+                for(Double result : values)
                 {
-                    while(!LOCK.tryLock()) {}
-                    File file = cameraToFile.get(cameraName);
-                    LOCK.unlock();
-                    while(!LOCK.tryLock()) {}
-                    Double result = TesseractFacade.imageToDouble(file);
-                    LOCK.unlock();
-                    while(!LOCK.tryLock()) {}
-                    resultMap.put(file,result);
-                    ErrorLogging.logError("Parsed value from camera " + cameraName +": " + result);
-                    LOCK.unlock();
                     if(result <= 10  || 
                        result >= 100 || 
                        result == Double.NEGATIVE_INFINITY)
                     {
-                        ErrorLogging.logError("Invalid OCR reading! Resetting DUTs...");
+                        logger.warn("Invalid OCR reading! Resetting DUTs...");
                         MovementFacade.goUp();
-                        ErrorLogging.logError("Waiting for 20 seconds to allow devices to fall asleep.");
+                        logger.info("Waiting for 20 seconds to allow devices to fall asleep.");
                         try{ Thread.sleep(20000); } 
-                        catch(Exception e){ ErrorLogging.logError(e); }
-                        ErrorLogging.logError("Waking devices...");
+                        catch(Exception e){ logger.error("Error caught!\nError: ",e); }
+                        logger.info("Waking devices...");
                         MovementFacade.pressButton();
                         fail = true;
                         break;
@@ -721,16 +736,14 @@ public class Cli
                 }
             }
             while(fail);
-
-            while(!LOCK.tryLock()) {}
-            DataSaving.writeValues(i,resultMap,cameraToFile);
-            LOCK.unlock();
-
-            //DO NOT CLEAR camera to file Map. This will change the order of the objects within it
-            resultMap.clear();
+            DataSaving.writeValues(state);
+            //dataEntryQueue.add(cycle);
+            //if(!writeThread.isAlive())
+            //    writeThread.start();
         }
-        println("=======================================");
-        println("Testing complete!");
+        //dataEntryQueue.add(new Cycle(-1));
+        logger.info("=======================================");
+        logger.info("Testing complete!");
     }
 
 
@@ -739,13 +752,12 @@ public class Cli
      */
     private static void close()
     {
-        ErrorLogging.logError("DEBUG: =================");
-        ErrorLogging.logError("DEBUG: PROGRAM CLOSING.");
-        ErrorLogging.logError("DEBUG: =================");
+        logger.debug("=================");
+        logger.debug("PROGRAM CLOSING.");
+        logger.debug("=================");
         if(inputScanner != null) inputScanner.close();
         if(safeGPIO) MovementFacade.closeGPIO();
-        ErrorLogging.logError("DEBUG: END OF PROGRAM.");
-        ErrorLogging.closeLogs();
+	logger.debug("End of program.");
         println("The program has exited successfully. Please press Ctrl-c to return to the terminal prompt.");
     }
 
@@ -852,7 +864,7 @@ public class Cli
      */
     private static void invalidInput(String input)
     {
-        ErrorLogging.logError("DEBUG: Invalid User Input!!! - Message to user: '" + input + "'");
+        logger.debug("Invalid User Input!!! - Message to user: '" + input + "'");
         println("");
         println("=================================================");
         println("Invalid input! - " + input);

src/main/java/org/baxter/disco/ocr/ConfigFacade.java

@@ -11,12 +11,17 @@ import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
+import java.time.format.DateTimeFormatter;
+import java.lang.invoke.MethodHandles;
 
 //Apache Commons Configuration imports
 import org.apache.commons.configuration2.INIConfiguration;
 import org.apache.commons.configuration2.builder.FileBasedConfigurationBuilder;
 import org.apache.commons.configuration2.builder.fluent.Parameters;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Facade for working with config files, using the Apache Commons 
  * Configuration library.
@@ -35,17 +40,19 @@ public class ConfigFacade
      */
     private static String configFileLocation = "config.ini";
 
+    private static DateTimeFormatter fileDateTime = DateTimeFormatter.ofPattern("yyyy-MM-dd_HH.mm.ss");
+
     /**
      * Location to save images to. 
      */
     private static String imageSaveLocation = "images-" + 
-        (LocalDateTime.now().format(ErrorLogging.fileDatetime));
+        (LocalDateTime.now().format(fileDateTime));
 
     /**
      * Location to save output XLSX file to.
      */
     private static String outputSaveLocation = "outputData/" + 
-        (LocalDateTime.now().format(ErrorLogging.fileDatetime)) + ".xlsx";
+        (LocalDateTime.now().format(fileDateTime)) + ".txt";
 
     /**
      * Map of all config values relating to the camera.
@@ -73,50 +80,55 @@ public class ConfigFacade
      */
     private static INIConfiguration CONFIG_STORE;
 
+    private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
+
+    private static double targetTemp = 36.0;
+    private static double failRange = 0.2;
+
     static 
     {
-        ErrorLogging.logError("Starting configuration setup...");
+        logger.debug("Starting configuration setup...");
         CONFIG_STORE = null;
 
         File configFile = new File(configFileLocation);
         boolean newConfig = true;
 
         try{ newConfig = configFile.createNewFile(); }
-        catch(Exception e){ ErrorLogging.logError(e); }
+        catch(Exception e){ logger.error("Error caught!\nError: ",e); }
 
-        ErrorLogging.logError("Creating config file interface...");
+        logger.debug("Creating config file interface...");
         CONFIG_BUILDER = new FileBasedConfigurationBuilder<>(INIConfiguration.class)
             .configure(new Parameters().fileBased().setFile(configFile));
 
-        ErrorLogging.logError("Attempting to import config..."); 
+        logger.debug("Attempting to import config..."); 
         if(!newConfig)
         {
             try { CONFIG_STORE = CONFIG_BUILDER.getConfiguration(); }
-            catch(Exception e) { ErrorLogging.logError(e); }
+            catch(Exception e) { logger.error("Error caught!\nError: ",e); }
             finally 
             { 
                 if(CONFIG_STORE == null) 
-                    ErrorLogging.logError("CONFIG INIT ERROR!!! - Unsuccessful "+
+                    logger.error("CONFIG INIT ERROR!!! - Unsuccessful "+
                             "config initialisation. Please delete the current config "+
                             "file, then restart this program!"); 
                 else
                 {
-                    ErrorLogging.logError("Config successfully imported!");
+                    logger.info("Config successfully imported!");
                     loadConfig(); 
-                    ErrorLogging.logError("Configuration settings loaded!");
+                    logger.info("Configuration settings loaded!");
                 }
             }
         }
 
         else
         {
-            ErrorLogging.logError("Unable to import config. Loading defaults...");
+            logger.warn("Unable to import config. Loading defaults...");
             boolean saveSuccessful = saveDefaultConfig();
-            if(!saveSuccessful) ErrorLogging.logError("Save config failed!!!");
-            else ErrorLogging.logError("Configuration settings set up!");
+            if(!saveSuccessful) logger.error("Save config failed!!!");
+            else logger.info("Configuration settings set up!");
         }
 
-        ErrorLogging.logError("Creating image storage directories...");
+        logger.debug("Creating image storage directories...");
         File imageLocation  = new File(imageSaveLocation);
         imageLocation.mkdir();
         File setupImageLocation  = new File(imageSaveLocation + "/config");
@@ -124,21 +136,23 @@ public class ConfigFacade
         File outputFileDirectory = new File("outputData");
         outputFileDirectory.mkdir();
 
-        ErrorLogging.logError("Creating output file....");
+        logger.debug("Creating output file....");
         File outputFile = new File(outputSaveLocation);
         try{ outputFile.createNewFile(); }
-        catch(Exception e){ ErrorLogging.logError(e); }
+        catch(Exception e){ logger.error("Error caught!\nError: ",e); }
 
         CONFIG_BUILDER.setAutoSave(true);
     }
 
+    public static double getLowerBound() { return targetTemp - failRange; }
+    public static double getUpperBound() { return targetTemp + failRange; }
     /**
      * Get a given config value. 
      * All values are stored as doubles.
      * Ints should be truncated.
      * Any boolean that should be false should be stored as 0.
      *
-     * @param cameraName    Name of the camera (defined in {@link OpenCVFacade})
+     * @param cameraName    Name of the camera (defined in {@link ImageFacade})
      * @param property      name of the property ({@link ConfigProperties})
      *
      * @return double of config value. Returns 0 if invalid input.
@@ -148,14 +162,15 @@ public class ConfigFacade
      */
     public static double getValue(String cameraName, ConfigProperties property)
     {
-        ErrorLogging.logError("DEBUG: Getting " + property.getConfig() + " for " + cameraName + "camera...");
+        logger.trace("Getting " + property.getConfig() + " for " + cameraName + "camera...");
         double output = 0.0;
         if(!CONFIG_MAP.keySet().contains(cameraName)) 
         {
-            ErrorLogging.logError("CONFIG ERROR!!! - Invalid camera name: " + cameraName);
-            ErrorLogging.logError("\tKey set: " + CONFIG_MAP.keySet().toString());
-            ErrorLogging.logError("\tProperty: " + property.getConfig());
-            ErrorLogging.logError("\tCONFIG_MAP keys: " + CONFIG_MAP.keySet().toString());
+            logger.error("CONFIG ERROR!!!");
+	    logger.debug("\tInvalid camera name: " + cameraName);
+            logger.debug("\tKey set: " + CONFIG_MAP.keySet().toString());
+            logger.debug("\tProperty: " + property.getConfig());
+            logger.debug("\tCONFIG_MAP keys: " + CONFIG_MAP.keySet().toString());
             return output;
         }
         Map<ConfigProperties,Double> cameraConfig = CONFIG_MAP.get(cameraName);
@@ -164,7 +179,7 @@ public class ConfigFacade
     }
 
     /**
-     * Initialises ConfigFacade and OpenCVFacade values
+     * Initialises ConfigFacade and ImageFacade values
      */
     public static void init() {}
 
@@ -183,17 +198,17 @@ public class ConfigFacade
      */
     public static boolean setOutputSaveLocation(String path)
     {
-        ErrorLogging.logError("DEBUG: Output save location modified!");
+        logger.debug("Output save location modified!");
         boolean output = false;
         if(Files.exists(Paths.get(path)))
         {
             outputSaveLocation = path;
-            ErrorLogging.logError("DEBUG: New output save location: " + outputSaveLocation);
+            logger.debug("DEBUG: New output save location: {}",outputSaveLocation);
             output = true;
         }
         else
         {
-            ErrorLogging.logError("DEBUG: Output save location modification failed.");
+            logger.warn("Output save location modification failed.");
         }
         return output;
     }
@@ -213,17 +228,17 @@ public class ConfigFacade
      */
     public static boolean setImgSaveLocation(String path)
     {
-        ErrorLogging.logError("DEBUG: Image save location modified!");
+        logger.debug("Image save location modified!");
         boolean output = false;
         if(Files.exists(Paths.get(path)))
         {
             imageSaveLocation = path;
-            ErrorLogging.logError("DEBUG: New image save location: " + outputSaveLocation);
+            logger.info("New image save location: {}",outputSaveLocation);
             output = true;
         }
         else
         {
-            ErrorLogging.logError("DEBUG: Output save location modification failed.");
+            logger.warn("Output save location modification failed.");
         }
         return output;
     }
@@ -238,12 +253,18 @@ public class ConfigFacade
      */
     public static boolean setValue(String cameraName, ConfigProperties property, double propertyValue)
     {
-        ErrorLogging.logError("DEBUG: Setting " + property.getConfig() + " to " + propertyValue + "for " + cameraName);
+        logger.debug("Setting {} to {} for {}",property.getConfig(),propertyValue,cameraName);
         boolean output = false;
 
-        List<String> activeCameras = new ArrayList<>(OpenCVFacade.getCameraNames());
+        List<String> activeCameras = new ArrayList<>(ImageFacade.getCameraNames());
         if(!activeCameras.contains(cameraName)) return output;
 
+	if(property == ConfigProperties.COMPOSITE_FRAMES && propertyValue <= 0)
+	{
+		logger.warn("Invalid value for composite frames! Please enter a positive number.");
+		return output;
+	}
+
         Map<ConfigProperties,Double> cameraConfig = CONFIG_MAP.get(cameraName);
         if(cameraConfig == null) return output;
 
@@ -292,22 +313,22 @@ public class ConfigFacade
      */
     public static boolean saveDefaultConfig(String filename)
     {
-        ErrorLogging.logError("DEBUG: Saving default config to " + filename);
+        logger.debug("Saving default config to " + filename);
         boolean output = false;
-        Set<String> cameraNames = OpenCVFacade.getCameraNames();
+        Set<String> cameraNames = ImageFacade.getCameraNames();
 
         CONFIG_BUILDER = new FileBasedConfigurationBuilder<>(INIConfiguration.class)
                              .configure(new Parameters().fileBased()
                              .setFile(new File(filename)));
 
         try { CONFIG_STORE = CONFIG_BUILDER.getConfiguration(); }
-        catch(Exception e) { ErrorLogging.logError(e); }
+        catch(Exception e) { logger.error("Error caught!\nError: ",e); }
         finally 
         { 
             if(CONFIG_STORE == null) 
             {
-                ErrorLogging.logError("CONFIG INIT ERROR!!! - Unsuccessful config initialisation. Camera commands will fail!"); 
-                ErrorLogging.logError("CONFIG INIT ERROR!!! - Attempted file save point: "+ filename);
+                logger.warn("CONFIG INIT ERROR!!! - Unsuccessful config initialisation. Camera commands will fail!"); 
+                logger.debug("Attempted file save point: {}",filename);
             }
         }
 
@@ -329,7 +350,7 @@ public class ConfigFacade
             CONFIG_BUILDER.save(); 
             output = true;
         }
-        catch(Exception e){ ErrorLogging.logError(e); }
+        catch(Exception e){ logger.error("Error caught!\nError: ",e); }
 
         return output;
     }
@@ -350,11 +371,11 @@ public class ConfigFacade
      */
     public static boolean saveCurrentConfig(String filename)
     {
-        ErrorLogging.logError("DEBUG: Saving current config to " + filename);
+        logger.debug("Saving current config to " + filename);
         boolean output = false;
 
         //Get a list of all cameras
-        List<String> activeCameras = new ArrayList<>(OpenCVFacade.getCameraNames());
+        List<String> activeCameras = new ArrayList<>(ImageFacade.getCameraNames());
 
         //For every available camera
         //  get every current property value, save it to the CONFIG_STORE
@@ -374,7 +395,7 @@ public class ConfigFacade
             CONFIG_BUILDER.save(); 
             output = true;
         }
-        catch(Exception e) { ErrorLogging.logError(e); }
+        catch(Exception e) { logger.error("Error caught!\nError: ",e); }
 
         return output;
     }
@@ -395,7 +416,7 @@ public class ConfigFacade
      */
     public static boolean loadConfig(String filename)
     {
-        ErrorLogging.logError("DEBUG: Attempting to load config from " + filename);
+        logger.debug("Attempting to load config from " + filename);
         //Check if the current CONFIG_MAP is empty
         boolean emptyMap = CONFIG_MAP.keySet().size() == 0;
         boolean output = false;
@@ -407,19 +428,19 @@ public class ConfigFacade
         { 
             if(file.createNewFile()) 
             {
-                ErrorLogging.logError("DEBUG: Listed file does not exist!");
+                logger.warn("Import of config file failed! Saving default config to default file location.");
                 return saveDefaultConfig(); 
             }
         }
         catch(Exception e)
         {
-            ErrorLogging.logError(e);
+        logger.warn("Import of config file failed! Saving default config to default file location.");
             return saveDefaultConfig(filename);
         }
 
         //At this point, the file should exist
         //Get a list of camera names
-        List<String> cameraNames = new ArrayList<>(OpenCVFacade.getCameraNames());
+        List<String> cameraNames = new ArrayList<>(ImageFacade.getCameraNames());
         if(Files.isRegularFile(Path.of(file.toURI())))
         {
             //Import the config file into a Java object
@@ -429,7 +450,7 @@ public class ConfigFacade
                     .configure(new Parameters().fileBased().setFile(file));
                 CONFIG_STORE = CONFIG_BUILDER.getConfiguration();
             }
-            catch(Exception e){ ErrorLogging.logError(e); }
+            catch(Exception e){ logger.error("Error caught!\nError: ",e); }
 
             //Iterate over the imported object, saving the file's config values to the map
             Set<String> configSections = CONFIG_STORE.getSections();
@@ -465,7 +486,7 @@ public class ConfigFacade
         }
 
         //If something broke, complain
-        if(!output) ErrorLogging.logError("CONFIG LOAD ERROR!!! - Invalid path.");
+        if(!output) logger.error("Invalid config file location.");
         return output;
     }
 
@@ -485,7 +506,7 @@ public class ConfigFacade
      */
     private static boolean saveSingleDefault(String sectionName)
     {
-        ErrorLogging.logError("DEBUG: Section unsuccessfully imported! Saving defaults to " + sectionName);
+        logger.debug("Saving defaults to " + sectionName);
         boolean output = false;
         Map<ConfigProperties,Double> cameraConfig = new HashMap<>();
         for(ConfigProperties property : ConfigProperties.values())
@@ -501,7 +522,7 @@ public class ConfigFacade
             CONFIG_BUILDER.save(); 
             output = true;
         }
-        catch(Exception e){ ErrorLogging.logError(e); }
+        catch(Exception e){ logger.error("Error caught!\nError: ",e); }
         return output;
     }
 }

src/main/java/org/baxter/disco/ocr/DataSaving.java

@@ -2,308 +2,145 @@ package org.baxter.disco.ocr;
 
 //Standard imports
 import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.DataInputStream;
-import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
+import java.util.Collections;
+import java.lang.invoke.MethodHandles;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-//Generic spreadsheet imports
-import org.apache.poi.ss.util.CellReference;
-import org.apache.poi.util.IOUtils;
-import org.apache.poi.ss.usermodel.DataFormat;
-import org.apache.poi.ss.usermodel.FillPatternType;
-import org.apache.poi.ss.usermodel.FormulaEvaluator;
-
-//Excel-specific imports
-import org.apache.poi.hssf.usermodel.HSSFCell;
-import org.apache.poi.hssf.usermodel.HSSFCellStyle;
-import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
-import org.apache.poi.hssf.usermodel.HSSFWorkbook;
-import org.apache.poi.hssf.usermodel.HSSFRow;
-import org.apache.poi.hssf.usermodel.HSSFSheet;
-import org.apache.poi.hssf.usermodel.HSSFPatriarch;
-import static org.apache.poi.hssf.util.HSSFColor.HSSFColorPredefined;
+import org.apache.commons.configuration2.INIConfiguration;
+import org.apache.commons.configuration2.builder.fluent.Parameters;
+import org.apache.commons.configuration2.builder.FileBasedConfigurationBuilder;
 
 /**
  * Facade for saving data out to a file.
  *
  * @author Blizzard Finnegan
- * @version 5.0.1, 10 Mar. 2023
+ * @version 7.0.0, 10 Mar. 2023
  */
 public class DataSaving
 {
     /**
-     * Workbook object; used for writing to the final XLSX file.
+     * Path to output file
      */
-    private static HSSFWorkbook outputWorkbook;
-    /**
-     * Object defining what sheet within the workbook we are working in.
-     */
-    private static HSSFSheet outputSheet;
+    private static String outputPath = ConfigFacade.getOutputSaveLocation();
 
     /**
-     * File representing the location of the final output file.
+     * Config API for the output file.
+     * This allows the output file to be easily read by both computers
+     * and people.
      */
-    private static File outputFile;
+    private static FileBasedConfigurationBuilder<INIConfiguration> OUTPUT_FILE =
+        new FileBasedConfigurationBuilder<>(INIConfiguration.class)
+        .configure(new Parameters().fileBased().setFile(new File(outputPath)));
 
     /**
-     * Default target temperature
+     * Config object for interacting with output values.
      */
-    private static double targetTemp = 36.0;
+    private static INIConfiguration outputValues;
 
     /**
-     * Default range for a measurement to be considered a fail
+     * Create local logger
      */
-    private static double failRange = 0.2;
+    private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
 
-    /**
-     * Style of cell if the measurement falls outside the fail range
-     */
-    private static HSSFCellStyle failStyle;
+    private static int iterationCount;
+    private static int passIterationCount;
+    private static double sum;
+    private static double stdDevIntermediate;
+    private static double stdDev;
+    private static double median;
+    private static final char SEPARATOR = '.';
 
-    /**
-     * Style of cell if Tesseract can't read the image
-     */
-    private static HSSFCellStyle errorStyle;
-
-    /**
-     * Style of a default cell
-     */
-    private static HSSFCellStyle defaultStyle;
-
-    /**
-     * Style of the total cells (sets typing to %)
-     */
-    private static HSSFCellStyle finalValuesStyle;
-
-    /**
-     * Prepares writer to write to XLSX file, with default fail values.
-     */
-    public static boolean initWorkbook(String filename, int camCount)
-    { return initWorkbook(filename, camCount, targetTemp, failRange); }
-
-    /**
-     * Prepares writer to write to XLSX file, with custom fail values.
-     */
-    public static boolean initWorkbook(String filename, int camCount, double targetTemp, double failRange)
+    static
     {
-        ErrorLogging.logError("DEBUG: Initialising workbook...");
-        DataSaving.targetTemp = targetTemp;
-        DataSaving.failRange = failRange;
-        boolean output = false;
-        outputFile = new File(filename);
-        DataFormat format = null;
-
-        //Create workbook, Sheet, and DataFormat object
-        //HSSF objects are used, as these are compatible with Microsoft Excel
-        outputWorkbook = new HSSFWorkbook(); 
-        outputSheet = outputWorkbook.createSheet();
-        format = outputWorkbook.createDataFormat();
-
-        defaultStyle = outputWorkbook.createCellStyle();
-        defaultStyle.setDataFormat(format.getFormat("0.0"));
-
-        finalValuesStyle = outputWorkbook.createCellStyle();
-        finalValuesStyle.setDataFormat(format.getFormat("0.000%"));
-
-        //Note on backgrounds:
-        //Excel cells have a foreground and a background, allowing
-        //for various patterned backgrounds. 
-        //To set a solid background, and NOT modify the font, 
-        //as below is shown, we need to set the foreground color.
-        //As of POI 5.2.3, there is no defined fill type 
-        //SOLID_BACKGROUND or similar
-        failStyle = outputWorkbook.createCellStyle();
-        failStyle.setFillForegroundColor(HSSFColorPredefined.RED.getIndex());
-        failStyle.setDataFormat(format.getFormat("0.0"));
-        failStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
-
-        errorStyle = outputWorkbook.createCellStyle();
-        errorStyle.setFillForegroundColor(HSSFColorPredefined.YELLOW.getIndex());
-        errorStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
-
-
-        int startingRow = outputSheet.getLastRowNum();
-        HSSFRow row = outputSheet.createRow(++startingRow);
-        int cellnum = 0;
-        HSSFCell cell = row.createCell(cellnum++);
-        cell.setCellValue("Iteration");
-        for(int i = 0; i < camCount; i++)
-        {
-            cell = row.createCell(cellnum++);
-            cell.setCellValue("Serial");
-            cell = row.createCell(cellnum++);
-            cell.setCellValue("Image Location");
-            cell = row.createCell(cellnum++);
-            cell.setCellValue("Read Value");
-            cell = row.createCell(cellnum++);
-            cell.setCellValue("");
-        }
-        HSSFCell serialTitleCell = row.createCell(cellnum++);
-        serialTitleCell.setCellValue("Serial");
-        HSSFCell passPercentCell = row.createCell(cellnum++);
-        passPercentCell.setCellValue("Pass %");
-
-        try (FileOutputStream outputStream = new FileOutputStream(outputFile))
-        { 
-            outputWorkbook.write(outputStream); 
-            ErrorLogging.logError("DEBUG: Initialising workbook completed successfully.");
-        }
-        catch(Exception e) 
-        {
-            ErrorLogging.logError("DEBUG: Workbook save failed!");
-            ErrorLogging.logError(e);
-        }
-
-        return output;
-    }
-
-    /**
-     * Add final totals to the excel document. 
-     *
-     * @param cameraCount   The number of cameras that were used.
-     */
-    private static void updateFormulas(int cameraCount)
-    {
-        ErrorLogging.logError("DEBUG: Updating formulas in Excel sheet...");
-        int rowIndex = 0;
-        FormulaEvaluator formulaEvaluator = outputWorkbook.getCreationHelper().createFormulaEvaluator();
-        int lastColumnOfData = outputSheet.getRow(rowIndex).getLastCellNum();
-        int serialColumn = lastColumnOfData - 2;
-        int percentColumn = lastColumnOfData - 1;
-        
-        int lastRowOfData = outputSheet.getLastRowNum();
-
-        int column = 1;
-        for(int i = 0; i < cameraCount; i++)
-        {
-            String serialColumnName = CellReference.convertNumToColString(column);
-            String dataColumnName = CellReference.convertNumToColString(column + 2);
-            ErrorLogging.logError("DEBUG: Serial Column name: " + serialColumnName);
-            HSSFRow row = outputSheet.getRow(++rowIndex);
-            if(row == null) 
-            {
-                row = outputSheet.createRow(rowIndex);
-            }
-            ErrorLogging.logError("DEBUG: Row index: " + rowIndex);
-            ErrorLogging.logError("DEBUG: Column (int): " + serialColumn);
-            HSSFCell serialCell = row.createCell(serialColumn);
-            String formula = "$" + serialColumnName + "$" + (rowIndex+1);
-            serialCell.setCellFormula(formula);
-            formulaEvaluator.evaluate(serialCell);
-
-            HSSFCell percentCell = row.createCell(percentColumn);
-            String verticalArray = String.format("$%s$2:$%s$%s",dataColumnName,dataColumnName,(lastRowOfData+1));
-            ErrorLogging.logError("DEBUG: Vertical Array: " + verticalArray);
-
-            formula = String.format(
-                "(COUNT(%s)-(COUNTIF(%s,\"<%s\")+COUNTIF(%s,\">%s\")))/(COUNT(%s))",
-                verticalArray,
-                verticalArray, (targetTemp - failRange), 
-                verticalArray, (targetTemp + failRange), 
-                verticalArray);
-            percentCell.setCellFormula(formula);
-
-            percentCell.setCellStyle(finalValuesStyle);
-
-            //To make the percentCell be a readable value, you need to
-            //evaluate the formula within the percentCell.
-            formulaEvaluator.evaluate(percentCell);
-
-            ErrorLogging.logError("DEBUG: Formula: " + formula);
-            column += 4;
-        }
-
-        try (FileOutputStream outputStream = new FileOutputStream(outputFile))
-        { outputWorkbook.write(outputStream); }
-        catch(Exception e) {ErrorLogging.logError(e);}
+        try { outputValues = OUTPUT_FILE.getConfiguration(); }
+        catch(Exception e){logger.error("Error caught!\nError: ",e); }
     }
 
     /** 
      * Writes line to XLSX file.
      *
      * @param cycle         What test cycle is being saved to the file 
-     * @param inputMap      Map[String,Double] list of inputs
+     * @param serials      Map[String,String] list of camera serials
      *
      * @return Returns whether values were saved successfully.
      */
-    public static boolean writeValues(int cycle, Map<File,Double> inputMap, Map<String,File> cameraToFile)
+    public static boolean writeValues(State state)
     {
-        ErrorLogging.logError("Writing values for " + cycle + " cycle to worksheet.");
         boolean output = false;
-        int cellnum = 0;
-        int startingRow = outputSheet.getLastRowNum();
-        HSSFRow row = (cycle == 1) ? outputSheet.getRow(startingRow) : outputSheet.createRow(++startingRow);
-        List<String> cameraNames = new ArrayList<>(cameraToFile.keySet());
-
-        cycle++;
-
-        HSSFCell indexCell = row.createCell(cellnum++);
-        indexCell.setCellValue(cycle);
-        for(String cameraName : cameraNames)
+        if(state.getDataMap().size() > 1)
         {
-            String serialNumber = ConfigFacade.getSerial(cameraName);
-            HSSFCell serialCell = row.createCell(cellnum++);
-            serialCell.setCellValue(serialNumber);
+            state.getDataMap().forEach( (serial,values) -> {
+                List<Double> valueList = new ArrayList<>(values.keySet());
+                Collections.sort(valueList);
+                List<Integer> indexList = new ArrayList<>();
+                iterationCount = 0;
+                passIterationCount = 0;
+                sum = 0;
+                stdDevIntermediate = 0;
+                median = 0;
+                values.forEach( (value,count) -> {
+                    iterationCount+= count;
+                    if(value > ConfigFacade.getLowerBound() && 
+                        value < ConfigFacade.getUpperBound())
+                        passIterationCount+=count;
+                    sum += value * count;
+                });
+                int counter = 0;
+                for(double value : valueList)
+                {
+                    counter += values.get(value);
+                    indexList.add(counter);
+                }
+                final double mean = (double)sum/(double)iterationCount;
+                int medianIndex = (iterationCount + 1) / 2;
+                if(indexList.size() <= 1){ median = valueList.get(0); }
+                else
+                {
+                    for(int i = 0; i < indexList.size(); i++)
+                    {
+                        int indexGuess = indexList.get(i);
+                        if(indexGuess >= medianIndex)
+                        {
+                            if(iterationCount % 2 == 0 || indexGuess > medianIndex + 1)
+                            {
+                                logger.trace("Index - 1: " + (i-1));
+                                logger.trace("Value passed into array get: " + (i-1 < 0 ? 0 : i-1));
+                                median = valueList.get((i-1 < 0 ? 0 : i-1));
+                            }
+                            else
+                                median = (valueList.get((i-1 < 0 ? 0 : i-1)) + valueList.get(i))/2.0;
+                        }
+                    }
+                }
 
-            File file = cameraToFile.get(cameraName);
-            HSSFCell imageCell = row.createCell(cellnum++);
-            try
-            {
-                InputStream cameraImage = new DataInputStream(new FileInputStream(file));
-                byte[] cameraImageRaw = IOUtils.toByteArray(cameraImage);
-                HSSFPatriarch patriarch = outputSheet.createDrawingPatriarch();
-                int imageID = outputWorkbook.addPicture(cameraImageRaw,HSSFWorkbook.PICTURE_TYPE_PNG);
-                HSSFClientAnchor imageAnchor = new HSSFClientAnchor();
-                imageAnchor.setCol1(cellnum-1);
-                imageAnchor.setCol2(cellnum);
-                imageAnchor.setRow1(startingRow);
-                imageAnchor.setRow2(startingRow+1);
-                patriarch.createPicture(imageAnchor, imageID);
-            } 
-            //If the image fails for some reason, fallback to putting the image path into the cell
-            catch(Exception e)
-            { 
-                String fileLocation = file.getPath();
-                imageCell.setCellValue(fileLocation);
-                ErrorLogging.logError(e); 
-            }
+                values.forEach( (value,count) -> {
+                    for(int i = 0; i < count; i++)
+                        stdDevIntermediate += Math.pow(value-mean,2);
+                });
 
-            //Put the OCR value into the sheet
-            HSSFCell ocrCell = row.createCell(cellnum++);
-            Double ocrRead = inputMap.get(file);
-            if(ocrRead.equals(Double.NEGATIVE_INFINITY))
-            {
-                ocrCell.setCellValue("ERROR!");
-                ocrCell.setCellStyle(errorStyle);
-            }
-            else
-            {
-                ocrCell.setCellValue(ocrRead);
-                if( ocrRead.doubleValue() > (targetTemp + failRange) ||
-                    ocrRead.doubleValue() < (targetTemp - failRange) )
-                    ocrCell.setCellStyle(failStyle);
-            }
+                stdDev = Math.sqrt(stdDevIntermediate / iterationCount);
 
-            //Create a blank cell as a spacer
-            row.createCell(cellnum++);
-        }
-        try (FileOutputStream outputStream = new FileOutputStream(outputFile))
-        { 
-            outputWorkbook.write(outputStream); 
-            output = true; 
-            ErrorLogging.logError("DEBUG: Writing values to Excel sheet was successful.");
-        }
-        catch(Exception e) 
+                String stdDevProperty = serial + SEPARATOR + "standard_deviation";
+                String totalProperty = serial + SEPARATOR + "total_iterations";
+                String passProperty = serial + SEPARATOR + "pass_iterations";
+                String medianProperty = serial + SEPARATOR + "median";
+
+                outputValues.setProperty(totalProperty,iterationCount);
+                outputValues.setProperty(passProperty,passIterationCount);
+                outputValues.setProperty(stdDevProperty,stdDev);
+                outputValues.setProperty(medianProperty,median);
+            });
+        };
+        try
         {
-            ErrorLogging.logError("DEBUG: Writing values to Excel sheet failed!");
-            ErrorLogging.logError(e);
+            OUTPUT_FILE.save();
+            output = true;
         }
-        updateFormulas(cameraNames.size());
+        catch(Exception e){ logger.error("Error caught!\nError: ",e);}
         return output;
     }
 }

src/main/java/org/baxter/disco/ocr/ErrorLogging.java

@@ -1,130 +0,0 @@
-package org.baxter.disco.ocr;
-
-//Standard imports
-import java.io.BufferedWriter;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.FileWriter;
-import java.io.PrintStream;
-import java.io.PrintWriter;
-import java.time.LocalDateTime;
-import java.time.format.DateTimeFormatter;
-
-//Error parsing import
-import org.apache.commons.lang3.exception.ExceptionUtils;
-
-/**
- * Class containing a single function for easily writing errors to a log file, 
- * as well as stderr.
- *
- * @author Blizzard Finnegan
- * @version 1.3.2, 07 Mar. 2023
- */
-
-public class ErrorLogging
-{
-    /**
-     * Name of the location for the logfile.
-     */
-    private static String logFile;
-
-    /**
-     * Object used to write streams of characters to the file.
-     *
-     * This intermediate object is required to use {@link BufferedWriter} properly.
-     */
-    private static FileWriter fw;
-
-    /**
-     * Object used for buffering file write functions, for improved efficiency.
-     */
-    private static BufferedWriter bw;
-
-    /**
-     * Object called to write to the file.
-     */
-    private static PrintWriter fileOut;
-
-    /**
-     * Object used to format UNIX timestamps into human-readable values.
-     */
-    private static DateTimeFormatter datetime;
-
-    /**
-     * Object used to format UNIX timestamps into human-readable values.
-     */
-    public static final DateTimeFormatter fileDatetime;
-
-    //This will always run first, before anything else in this file
-    static
-    {
-        //Make sure the filename formatter is compatible with Windows and Linux
-        fileDatetime = DateTimeFormatter.ofPattern("yyyy-MM-dd_HH.mm.ss");
-
-        datetime = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
-
-        logFile =  "logs/" + fileDatetime.format(LocalDateTime.now()) + "-log.txt";
-        File logDirectory = new File("logs");
-        File outFile = new File(logFile);
-        try
-        {
-            logDirectory.mkdir();
-            outFile.createNewFile();
-            fw = new FileWriter(logFile, true);
-            bw = new BufferedWriter(fw);
-            fileOut = new PrintWriter(bw);
-            System.setErr(new PrintStream(new FileOutputStream(logFile,true)));
-        }
-        catch (Exception e)
-        {
-            System.err.println(e);
-        }
-    }
-
-    /**
-     * Logs error thrown by runtime.
-     * Prepends the current date and time to the log line.
-     *
-     * @param error     Any error being thrown to be logged.
-     */
-    public static void logError(Throwable error)
-    {
-        String errorStackTrace = ExceptionUtils.getStackTrace(error);
-        String errorMessage = datetime.format(LocalDateTime.now())  + " - " + errorStackTrace;
-        fileOut.println(errorMessage);
-        fileOut.flush();
-    }
-
-    /**
-     * Logs data manually set by the developer.
-     *
-     * @param error     Any information to save to the log file.
-     */
-    public static void logError(String error)
-    {
-        String errorMessage = datetime.format(LocalDateTime.now())  + "\t- " + error;
-        fileOut.println(errorMessage);
-        fileOut.flush();
-        if(!error.substring(0,5).equals("DEBUG"))
-            System.out.println(errorMessage);
-    }
-
-    /**
-     * Close all open logs. 
-     */
-    public static void closeLogs() 
-    { 
-        try{}
-        finally
-        {
-            if(fileOut != null) fileOut.close();
-            try 
-            {
-            if(bw != null) bw.close();
-            if(fw != null) fw.close();
-            }
-            catch(Exception e) 
-            { /* This is being run because the program is closing. Errors here don't matter. */}
-        }
-    }
-}

src/main/java/org/baxter/disco/ocr/ImageFacade.java

@@ -1,6 +1,6 @@
 package org.baxter.disco.ocr;
 
-//Static imports for OpenCV
+//Static imports 
 import static org.bytedeco.opencv.global.opencv_imgproc.CV_BGR2GRAY;
 import static org.bytedeco.opencv.global.opencv_imgproc.THRESH_BINARY;
 import static org.bytedeco.opencv.global.opencv_imgproc.cvtColor;
@@ -9,6 +9,7 @@ import static org.bytedeco.opencv.global.opencv_imgcodecs.imread;
 import static org.bytedeco.opencv.global.opencv_imgcodecs.cvSaveImage;
 import static org.bytedeco.opencv.global.opencv_highgui.selectROI;
 import static org.bytedeco.opencv.global.opencv_core.bitwise_and;
+import static org.bytedeco.leptonica.global.leptonica.pixRead;
 
 //JavaCV imports
 import org.bytedeco.javacv.Frame;
@@ -22,15 +23,26 @@ import org.bytedeco.opencv.opencv_core.Mat;
 import org.bytedeco.opencv.opencv_core.IplImage;
 import org.bytedeco.opencv.opencv_core.Rect;
 
+//Tesseract imports
+import org.bytedeco.tesseract.TessBaseAPI;
+import org.bytedeco.leptonica.PIX;
+
 //Standard imports
 import java.util.Map;
 import java.util.Set;
 import java.io.File;
+import java.io.FileWriter;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Scanner;
+import java.lang.invoke.MethodHandles;
+import java.time.format.DateTimeFormatter;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * Facade for the OpenCV package.
@@ -39,7 +51,7 @@ import java.util.List;
  * @author Blizzard Finnegan
  * @version 3.0.0, 10 Mar. 2023
  */
-public class OpenCVFacade
+public class ImageFacade
 {
     /**
      * Storage of all cameras as Map.
@@ -74,10 +86,52 @@ public class OpenCVFacade
      */
     private static final String CAMERA_FILE_PREFIX = "video-cam-";
 
+    /**
+     * Logger creation
+     */
+    private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
+
+    /**
+     * Date time formatter
+     */
+    private static DateTimeFormatter fileDateTime = DateTimeFormatter.ofPattern("yyyy-MM-dd_HH.mm.ss");
+
+    /**
+     *Tesseract API Object
+     */
+    private static TessBaseAPI api;
+
+    /**
+     * <pre>
+     * OCR engine mode.
+     *
+     * From https://ai-facets.org/tesseract-ocr-best-practices/:
+     *  0: Legacy engine only
+     *  1: Neural nets Long Short-Term Memory (LSTM) engine only. This form of neural network has feedback, as well as feedforward within the design, allowing the neural network to learn from itself.
+     *  2: Legacy + LSTM engines
+     *  3: Default, based on what is available
+     *
+     * As I didn't write the training data, and don't actually know what kind of network the training set requires, this value is set to default.
+     * </pre>
+     */
+    private static final int OCR_ENGINE_MODE = 3;
+
+    /**
+     * OCR language name, or training data filename.
+     */
+    private static final String OCR_LANGUAGE = "Pro6_temp_test";
+
+    /**
+     * Location on the file system that the OCR languages are stored.
+     *
+     * This value requires that the folder "tessdata" be in the same location as your current working directory. 
+     */
+    private static final String OCR_LANGUAGE_LOCATION = "tessdata";
+
     //Initial Camera creation
     static
     {
-        ErrorLogging.logError("Initialising cameras...");
+        logger.debug("Initialising cameras...");
         File devDirectory = new File("/dev");
         for(File cameraFile : devDirectory.listFiles(
                     (file) -> { return file.getName().contains(CAMERA_FILE_PREFIX); }))
@@ -86,6 +140,9 @@ public class OpenCVFacade
                                 substring(CAMERA_FILE_PREFIX.length());
             newCamera(cameraName, cameraFile.getAbsolutePath());
         }
+        logger.debug("Initialising tesseract api...");
+        api = new TessBaseAPI();
+        api.Init(OCR_LANGUAGE_LOCATION, OCR_LANGUAGE, OCR_ENGINE_MODE);
     }
 
     /**
@@ -113,7 +170,7 @@ public class OpenCVFacade
      */
     private static void newCamera(String name, String location, int width, int height, String codec)
     {
-        ErrorLogging.logError("Initialising camera : " + name + "...");
+        logger.debug("Initialising camera : " + name + "...");
         File cameraLocation = new File(location);
         if (cameraLocation.exists())
         {
@@ -121,8 +178,7 @@ public class OpenCVFacade
             try{ camera.start(); }
             catch(Exception e) 
             { 
-                ErrorLogging.logError(e); 
-                ErrorLogging.logError("CAMERA INIT ERROR!!! - Camera failed to initialise. Use of camera " + name + " will fail.");
+                logger.error("CAMERA INIT ERROR!!! - Camera failed to initialise. Use of camera " + name + " will fail.");
                 return;
             }
             camera.setFormat(codec);
@@ -132,7 +188,7 @@ public class OpenCVFacade
         }
         else
         {
-            ErrorLogging.logError("CAMERA INIT ERROR!!! - Illegal camera location.");
+            logger.error("CAMERA INIT ERROR!!! - Illegal camera location.");
         }
     }
 
@@ -156,14 +212,14 @@ public class OpenCVFacade
      */
     private static Mat takePicture(String cameraName)
     {
-        ErrorLogging.logError("DEBUG: Taking picture...");
+        logger.debug("Taking picture...");
         Mat output = null;
         Frame temp = null;
 
         if(getCameraNames().contains(cameraName))
         {
             try{ temp = cameraMap.get(cameraName).grab(); }
-            catch(Exception e) { ErrorLogging.logError(e); }
+            catch(Exception e) { logger.error("Error caught!\nError: ",e); }
 
             //Convert to grayscale
             Mat in = MAT_CONVERTER.convertToMat(temp);
@@ -172,7 +228,7 @@ public class OpenCVFacade
         }
         else
         {
-            ErrorLogging.logError("DEBUG: Invalid camera!");
+            logger.warn("Invalid camera!");
         }
 
         return output;
@@ -187,7 +243,7 @@ public class OpenCVFacade
      */
     public static File showImage(String cameraName)
     {
-        ErrorLogging.logError("DEBUG: Showing preview...");
+        logger.debug("Showing preview...");
         File imageLocation = completeProcess(cameraName,ConfigFacade.getImgSaveLocation() + "/config");
         if(imageLocation == null) return null;
         Frame outputImage = MAT_CONVERTER.convert(imread(imageLocation.getAbsolutePath()));
@@ -220,7 +276,7 @@ public class OpenCVFacade
      */
     private static List<Mat> takeBurst(String cameraName, int frameCount)
     {
-        ErrorLogging.logError("DEBUG: Taking burst of " + frameCount + " images...");
+        logger.debug("Taking burst of " + frameCount + " images...");
         List<Mat> output = null;
         if(getCameraNames().contains(cameraName))
         {
@@ -232,7 +288,7 @@ public class OpenCVFacade
         }
         else
         {
-            ErrorLogging.logError("DEBUG: Invalid camera!");
+            logger.warn("Invalid camera!");
         }
         return output;
     }
@@ -247,12 +303,12 @@ public class OpenCVFacade
         Mat uncroppedImage = takePicture(cameraName);
         if(uncroppedImage != null)
         {
-            ErrorLogging.logError("DEBUG: Allowing user to modify crop.");
+            logger.debug("Allowing user to modify crop.");
             Rect roi = selectROI("Pick Crop Location", uncroppedImage);
             if(roi.x() == 0 && roi.y() == 0 && roi.width() == 0 && roi.height() == 0)
             {
-                ErrorLogging.logError("Crop error! - Invalid crop selection.");
-                ErrorLogging.logError("If the crop region did not have a box indicating is location, please restart the program.");
+                logger.warn("Crop error! - Invalid crop selection.");
+                logger.warn("If the crop region did not have a box indicating is location, please restart the program.");
                 ConfigFacade.setValue(cameraName,ConfigProperties.CROP_X,ConfigProperties.CROP_X.getDefaultValue());
                 ConfigFacade.setValue(cameraName,ConfigProperties.CROP_Y,ConfigProperties.CROP_Y.getDefaultValue());
                 ConfigFacade.setValue(cameraName,ConfigProperties.CROP_W,ConfigProperties.CROP_W.getDefaultValue());
@@ -338,10 +394,10 @@ public class OpenCVFacade
      */
     private static File saveImage(Mat image, String fileLocation, String cameraName)
     {
-        ErrorLogging.logError("DEBUG: Saving image from " + cameraName + " to " + fileLocation);
+        logger.debug("Saving image from " + cameraName + " to " + fileLocation);
         File output = null;
         IplImage temp = MAT_CONVERTER.convertToIplImage(MAT_CONVERTER.convert(image));
-        fileLocation = fileLocation + "/" + ErrorLogging.fileDatetime.format(LocalDateTime.now()) + "-" + cameraName + ".png";
+        fileLocation = fileLocation + "/" + fileDateTime.format(LocalDateTime.now()) + "-" + cameraName + ".png";
         cvSaveImage(fileLocation,temp);
         output = new File(fileLocation);
         return output;
@@ -358,7 +414,7 @@ public class OpenCVFacade
      */
     private static Mat compose(List<Mat> images)
     {
-        ErrorLogging.logError("DEBUG: Attempting to compose " + images.size() + " images...");
+        logger.debug("Attempting to compose " + images.size() + " images...");
         Mat output = null;
         for(Mat image : images)
         { 
@@ -371,8 +427,8 @@ public class OpenCVFacade
 
         }
 
-        if(output != null)  ErrorLogging.logError("DEBUG: Compositing successful!");
-        else                ErrorLogging.logError("ERROR: Final output image is null!");
+        if(output != null)  logger.debug("Compositing successful!");
+        else                logger.warn("Final output image is null!");
         return output;
     }
 
@@ -395,15 +451,15 @@ public class OpenCVFacade
         File output = null;
         if(!getCameraNames().contains(cameraName))
         {
-            ErrorLogging.logError("OPENCV ERROR!!! - Invalid camera name.");
+            logger.warn("OPENCV ERROR!!! - Invalid camera name.");
             return output;
         }
         List<Mat> imageList = takeBurst(cameraName, compositeFrames);
         List<Mat> processedImageList = new ArrayList<>();
 
         Mat finalImage = null;
-        if(crop)        ErrorLogging.logError("Cropping is enabled.");
-        if(threshold)   ErrorLogging.logError("Thresholding is enabled.");
+        if(crop)        logger.debug("Cropping is enabled.");
+        if(threshold)   logger.debug("Thresholding is enabled.");
         for(Mat image : imageList)
         {
             Mat processedImage = image.clone();
@@ -444,7 +500,7 @@ public class OpenCVFacade
 
         if(!getCameraNames().contains(cameraName))
         {
-            ErrorLogging.logError("OPENCV ERROR!!! - Invalid camera name.");
+            logger.warn("OPENCV ERROR!!! - Invalid camera name.");
             return output;
         }
 
@@ -455,7 +511,7 @@ public class OpenCVFacade
 
         output = completeProcess(cameraName,crop,threshold,compositeFrames,saveLocation);
 
-        if(output == null) ErrorLogging.logError("OPENCV ERROR!!!: Final processed image is null!");
+        if(output == null) logger.error("OPENCV ERROR!!!: Final processed image is null!");
         return output;
     }
 
@@ -469,4 +525,62 @@ public class OpenCVFacade
      */
     public static File completeProcess(String cameraName)
     { return completeProcess(cameraName,ConfigFacade.getImgSaveLocation()); }
+
+    /** 
+     * Converts an image file to a double.
+     *
+     * @param file  File object of the image to be parsed by Tesseract.
+     * @return Double, as read from the image by Tesseract. Anomalous data returns Double.NEGATIVE_INFINITY
+     */
+    public static double imageToDouble(File file)
+    {
+        double output = Double.NEGATIVE_INFINITY;
+
+        PIX importedImage = pixRead(file.getAbsolutePath());
+        api.SetImage(importedImage);
+        String stringOutput = api.GetUTF8Text().getString();
+
+        if(!stringOutput.isEmpty())
+        {
+            try( Scanner sc = new Scanner(stringOutput.trim()); )
+            {
+                if(sc.hasNextDouble()) 
+                {
+                    output = sc.nextDouble();
+                    if(output >= 200) 
+                    {
+                        logger.warn("OCR WARNING - OCR output is too high for DUT, attempting to adjust...");
+                        output = output / 10;
+                        if(output >= 300)
+                        {
+                            output = output / 10;
+                            logger.warn("OCR output saved, as value appears to be real. Value needs to be verified.");
+                        }
+                        else if(output >= 200)  logger.warn("OCR output is too high for DUT, potential misread.");
+                        else            logger.warn("OCR output successfully adjusted. Disregard warning.");
+                    }
+                    if(output <= -10)   logger.warn("OCR output is too low  for DUT, potential misread.");
+                }
+                else logger.error("OCR output is not a Double.");
+            }
+        }
+        else { logger.error("OCR Failed to retrieve information!"); }
+
+        logger.info("Tesseract parsed value: {}",output);
+
+        if(output == Double.NEGATIVE_INFINITY || 
+            output > ConfigFacade.getUpperBound() ||
+            output < ConfigFacade.getLowerBound())
+        {
+            try (FileWriter fileWriter = new FileWriter("invalid_OCR_reads.txt",true))
+            {
+                fileWriter.write(file.getPath() + "\n");
+            }
+            catch(Exception e)
+            {
+                logger.error("Error caught!\nError: ",e);
+            }
+        }
+        return output;
+    }
 }

src/main/java/org/baxter/disco/ocr/MovementFacade.java

@@ -10,6 +10,11 @@ import com.pi4j.io.gpio.digital.DigitalOutputConfigBuilder;
 import com.pi4j.io.gpio.digital.DigitalState;
 import com.pi4j.io.gpio.digital.PullResistance;
 
+import java.lang.invoke.MethodHandles;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Facade for all movement of the fixture.
  *
@@ -17,7 +22,7 @@ import com.pi4j.io.gpio.digital.PullResistance;
  * Currently missing Run switch compatibility.
  *
  * @author Blizzard Finnegan
- * @version 3.0.1, 10 Mar. 2023
+ * @version 3.3.0, 20 Mar. 2023
  */
 public class MovementFacade
 {
@@ -32,6 +37,11 @@ public class MovementFacade
      */
     private static Thread runSwitchThread;
 
+    /**
+     * Lock object for multithreading/run switch.
+     */
+    private static final Object lockObject = new Object();
+
     /**
      * Fraction of the total travel time, so the arm won't push through the limit switch.
      */
@@ -51,10 +61,11 @@ public class MovementFacade
 
     /**
      * How many polls before assuming bad GPIO connection.
-     * Fixture movement takes approximately 2.5s, or 250 polls.
-     * Double this to account for errors, or slower fixtures.
+     * The DUTs fall asleep after ~6 seconds,so the travel must be less than 3 seconds.
      */
-    private static final int TIMEOUT = 500;
+    private static final int TIMEOUT = 300;
+
+    private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
 
 
     //PWM Addresses
@@ -161,12 +172,12 @@ public class MovementFacade
     {
         pi4j = Pi4J.newAutoContext();
 
-        ErrorLogging.logError("DEBUG: Opening input GPIO pins...");
+        logger.debug("Opening input GPIO pins...");
         upperLimit = inputBuilder(UPPER_LIMIT_ADDR);
         lowerLimit = inputBuilder(LOWER_LIMIT_ADDR);
         runSwitch  = inputBuilder(RUN_SWITCH_ADDR);
 
-        ErrorLogging.logError("DEBUG: Opening output GPIO pins...");
+        logger.debug("Opening output GPIO pins...");
         motorEnable    = outputBuilder(MOTOR_ENABLE_ADDR);
         motorDirection = outputBuilder(MOTOR_DIRECTION_ADDR);
         pistonActivate = outputBuilder(PISTON_ADDR);
@@ -178,31 +189,35 @@ public class MovementFacade
         }
         catch(Exception e)
         {
-            ErrorLogging.logError(e);
+            logger.debug("Error expected.\nError caught: ",e);
             pi4j.shutdown();
             throw new Exception("GPIO init error!!! Check GPIO connections.");
         }
 
-        ErrorLogging.logError("DEBUG: Starting lock thread...");
+        logger.debug("Starting lock thread...");
         runSwitchThread = new Thread(() -> 
                 {
-                    boolean unlock = false;
                     while(!exit)
                     {
                         if(runSwitch.isOn())
                         {
-                            ErrorLogging.logError("DEBUG: Run switch turned off!");
-                            while(!Cli.LOCK.tryLock())
-                            {}
-                            unlock = true;
+                            synchronized(lockObject)
+                            {
+                                while(runSwitch.isOn())
+                                {
+                                    try{ Thread.sleep(100); } catch(Exception e){logger.error("Error caught!\nError: ",e);}
+                                    if(runSwitch.isOff())
+                                    {
+                                        try{ Thread.sleep(100); } catch(Exception e){logger.error("Error caught!\nError: ",e);}
+                                        if(runSwitch.isOff())
+                                        {
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
                         }
-                        else
-                        {
-                            //ErrorLogging.logError("Run switch on!");
-                            if(unlock) 
-                            { Cli.LOCK.unlock(); unlock = false; }
-                        }
-                        try{ Thread.sleep(100); } catch(Exception e) { ErrorLogging.logError(e); }
+                        try{ Thread.sleep(1); } catch(Exception e){logger.error("Error caught!\nError: ",e);}
                     }
                 }, "Run switch monitor.");
         runSwitchThread.start();
@@ -250,43 +265,51 @@ public class MovementFacade
      */
     public static int resetArm()
     {
-        ErrorLogging.logError("DEBUG: --------------------------------------");
-        ErrorLogging.logError("DEBUG: Resetting arm...");
+        logger.debug("--------------------------------------");
+        logger.debug("Resetting arm...");
         int counter;
         if(upperLimit.isHigh())
         {
-            ErrorLogging.logError("DEBUG: Motor at highest point! Lowering to reset.");
-            motorDirectionDown();
-            motorOn();
-            try{ Thread.sleep(500); }
-            catch (Exception e){ ErrorLogging.logError(e); }
-            motorOff();
-        }
-        ErrorLogging.logError("DEBUG: Moving motor to highest point.");
-        motorDirectionUp();
-
-        motorOn();
-
-        for(counter = 0; counter < TIMEOUT; counter++)
-        { 
-            try{ Thread.sleep(POLL_WAIT); } catch(Exception e){ ErrorLogging.logError(e); }
-            if(upperLimit.isOn()) 
+            logger.debug("Motor at highest point! Lowering to reset.");
+            synchronized(lockObject)
             {
-                try{ Thread.sleep(1); } catch(Exception e){ErrorLogging.logError(e); }
-                if(upperLimit.isOn()) break;
+                motorDirectionDown();
+                motorOn();
+                try{ Thread.sleep(500); }
+                catch (Exception e){ logger.error("Error caught!\nError: ",e); }
+                motorOff();
             }
         }
-        motorOff();
+        logger.debug("Moving motor to highest point.");
+        motorDirectionUp();
+
+        synchronized(lockObject)
+        {
+            motorOn();
+
+            for(counter = 0; counter < TIMEOUT; counter++)
+            { 
+                try{ Thread.sleep(POLL_WAIT); } catch(Exception e){ logger.error("Error caught!\nError: ",e); }
+                if(upperLimit.isOn()) 
+                {
+                    try{ Thread.sleep(1); } catch(Exception e){logger.error("Error caught!\nError: ",e); }
+                    if(upperLimit.isOn()) break;
+                }
+            }
+            motorOff();
+        }
+
         if(counter < TIMEOUT)
         {
-            ErrorLogging.logError("DEBUG: Motor returned after " + counter + " polls.");
-            ErrorLogging.logError("DEBUG: --------------------------------------");
+            logger.debug("Motor returned after " + counter + " polls.");
+            logger.debug("--------------------------------------");
             return counter;
         }
+
         else
         {
-            ErrorLogging.logError("DEBUG: No motor return after 30 seconds.");
-            ErrorLogging.logError("DEBUG: --------------------------------------");
+            logger.warn("No motor return after 3 seconds.");
+            logger.debug("--------------------------------------");
             return -1;
         }
     }
@@ -296,42 +319,44 @@ public class MovementFacade
      */
     private static void findDistance() throws Exception
     {
-        ErrorLogging.logError("DEBUG: Measuring travel time to buttons...");
+        logger.debug("Measuring travel time to buttons...");
         int safeGPIO = resetArm();
         if(safeGPIO < 0) throw new Exception("Failed GPIO initialisation!");
         int downTravelCounter = 0;
         int upTravelCounter = 0;
         motorDirectionDown();
         motorOn();
-        for(downTravelCounter = 0; downTravelCounter < Integer.MAX_VALUE; downTravelCounter++)
+        for(downTravelCounter = 0; downTravelCounter < TIMEOUT; downTravelCounter++)
         {
-            try{ Thread.sleep(POLL_WAIT); } catch(Exception e){ ErrorLogging.logError(e); }
+            try{ Thread.sleep(POLL_WAIT); } catch(Exception e){ logger.error("Error caught!\nError: ",e); }
             if(lowerLimit.isOn()) 
             {
-                try{ Thread.sleep(1); } catch(Exception e){ErrorLogging.logError(e); }
+                try{ Thread.sleep(1); } catch(Exception e){logger.error("Error caught!\nError: ",e); }
                 if(lowerLimit.isOn()) break;
             }
         }
         motorOff();
-        if(lowerLimit.isOff()) ErrorLogging.logError("DEBUG: False positive on findDistance down!");
+        if(lowerLimit.isOff()) logger.debug("False positive on findDistance down!");
+        if(downTravelCounter == TIMEOUT) throw new Exception("PWM set too slow!");
         
-        ErrorLogging.logError("DEBUG: Down travel count: " + downTravelCounter);
+        logger.debug("Down travel count: " + downTravelCounter);
 
         motorDirectionUp();
         motorOn();
-        for(upTravelCounter = 0; upTravelCounter < Integer.MAX_VALUE; upTravelCounter++)
+        for(upTravelCounter = 0; upTravelCounter < TIMEOUT; upTravelCounter++)
         { 
-            try{ Thread.sleep(POLL_WAIT); } catch(Exception e){ ErrorLogging.logError(e); }
+            try{ Thread.sleep(POLL_WAIT); } catch(Exception e){ logger.error("Error caught\nError: ",e); }
             if(upperLimit.isOn()) 
             {
-                try{ Thread.sleep(1); } catch(Exception e){ErrorLogging.logError(e); }
+                try{ Thread.sleep(1); } catch(Exception e){logger.error("Error caught!\nError: ",e); }
                 if(upperLimit.isOn()) break;
             }
         }
         motorOff();
-        if(upperLimit.isOff()) ErrorLogging.logError("DEBUG: False positive on findDistance up!");
+        if(upperLimit.isOff()) logger.debug("False positive on findDistance up!");
+        if(upTravelCounter == TIMEOUT) throw new Exception("Failed GPIO initialisation!");
 
-        ErrorLogging.logError("DEBUG: Up travel count: " + downTravelCounter);
+        logger.debug("Up travel count: " + downTravelCounter);
 
         int travelCounter = Math.min(upTravelCounter, downTravelCounter);
         TRAVEL_DIST = travelCounter;
@@ -367,21 +392,27 @@ public class MovementFacade
 
         int totalPollCount = (int)(TRAVEL_DIST);
         int highSpeedPolls = (int)(totalPollCount * SLOW_POLL_FACTOR);
-        ErrorLogging.logError("DEBUG: =============================");
-        ErrorLogging.logError("DEBUG: Travel time: " + totalPollCount);
-        ErrorLogging.logError("DEBUG: High speed poll count: " + highSpeedPolls);
-        ErrorLogging.logError("DEBUG: =============================");
-        motorOn();
-        for(int i = 0; i < highSpeedPolls; i++)
+        logger.trace("Travel time: " + totalPollCount);
+        logger.trace("High speed poll count: " + highSpeedPolls);
+
+        synchronized(lockObject)
         {
-            try{ Thread.sleep(POLL_WAIT); } catch(Exception e){ ErrorLogging.logError(e); }
-            if(limitSense.isOn())
+            motorOn();
+            for(int i = 0; i < highSpeedPolls; i++)
             {
-                motorOff();
-                break;
+                try{ Thread.sleep(POLL_WAIT); } catch(Exception e){ logger.error("Error caught!\nError: ",e); }
+                if(limitSense.isOn())
+                {
+                    try{ Thread.sleep(5); } catch(Exception e){logger.error("Error caught!\nError: ",e); }
+                    if(limitSense.isOn()) 
+                    {
+                        motorOff();
+                        break;
+                    }
+                }
             }
+            motorOff();
         }
-        motorOff();
 
         output = (limitSense.isOn() ? FinalState.UNSAFE : FinalState.SAFE);
 
@@ -407,11 +438,14 @@ public class MovementFacade
      */
     public static void pressButton()
     {
-        ErrorLogging.logError("DEBUG: Pressing button...");
-        pistonActivate.on();
-        try{ Thread.sleep(1000); } catch(Exception e) {ErrorLogging.logError(e);};
-        ErrorLogging.logError("DEBUG: Releasing button...");
-        pistonActivate.off();
+        synchronized(lockObject)
+        {
+            logger.debug("Pressing button...");
+            pistonActivate.on();
+            try{ Thread.sleep(1000); } catch(Exception e) {logger.error("Error caught!\nError: ",e); }
+            logger.debug("Releasing button...");
+            pistonActivate.off();
+        }
     }
 
     /**
@@ -438,31 +472,31 @@ public class MovementFacade
         goUp();
         if(prime) pressButton();
         goDown();
-        try{ Thread.sleep(100); } catch(Exception e){ ErrorLogging.logError(e); }
+        try{ Thread.sleep(100); } catch(Exception e){ logger.error("Error caught!\nError: ",e); }
         pressButton();
     }
 
     private static void motorOn()
     {
-        ErrorLogging.logError("DEBUG: Motor on.");
+        logger.debug("Motor on.");
         motorEnable.on();
     }
 
     private static void motorOff()
     {
-        ErrorLogging.logError("DEBUG: Motor off.");
+        logger.debug("Motor off.");
         motorEnable.off();
     }
 
     private static void motorDirectionUp()
     {
-        ErrorLogging.logError("DEBUG: Motor travelling up.");
+        logger.debug("Motor travelling up.");
         motorDirection.high();
     }
 
     private static void motorDirectionDown()
     {
-        ErrorLogging.logError("DEBUG: Motor travelling down.");
+        logger.debug("Motor travelling down.");
         motorDirection.low();
     }
 

src/main/java/org/baxter/disco/ocr/State.java

@@ -0,0 +1,35 @@
+package org.baxter.disco.ocr;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class State
+{
+    private Map<String,Map<Double,Integer>> cameraDataMap = new HashMap<>();
+
+    public State(Map<String,String> serials)
+    {
+        serials.forEach( (camera,serial) -> {
+            cameraDataMap.put(serial,new HashMap<>());
+        });
+    }
+
+    public synchronized boolean addIteration(String camera, double readValue)
+    {
+        boolean output = false;
+        if(!cameraDataMap.keySet().contains(camera)) return output;
+
+        if(!cameraDataMap.get(camera).keySet().contains(readValue))
+            cameraDataMap.get(camera).put(readValue,1);
+
+        else
+            cameraDataMap.get(camera).
+                put(readValue, (cameraDataMap.get(camera).get(readValue) + 1));
+
+        return output;
+    }
+
+    public synchronized Map<String,Map<Double,Integer>> getDataMap() { return this.cameraDataMap; }
+
+    public synchronized Map<Double,Integer> getSerialDataMap(String serial) { return this.cameraDataMap.get(serial); }
+}

src/main/java/org/baxter/disco/ocr/TesseractFacade.java

@@ -1,107 +0,0 @@
-package org.baxter.disco.ocr;
-
-//Standard imports
-import java.io.File;
-import java.util.Scanner;
-
-//Static import of image reader
-import static org.bytedeco.leptonica.global.leptonica.pixRead;
-
-//Import Tesseract-capable image class
-import org.bytedeco.leptonica.PIX;
-
-//Import Tesseract API
-import org.bytedeco.tesseract.TessBaseAPI;
-
-/**
- * Facade for Tesseract API.
- *
- * Wrapper around Tesseract API, feeding in defaults and necessary
- * information for this specific testing aparatus.
- *
- * @author Blizzard Finnegan
- * @version 2.2.1, 27 Feb. 2023
- */
-public class TesseractFacade
-{
-    
-    /**
-     * API object for Tesseract.
-     */
-    private static TessBaseAPI api;
-
-    /**
-     * <pre>
-     * OCR engine mode.
-     *
-     * From https://ai-facets.org/tesseract-ocr-best-practices/:
-     *  0: Legacy engine only
-     *  1: Neural nets Long Short-Term Memory (LSTM) engine only. This form of neural network has feedback, as well as feedforward within the design, allowing the neural network to learn from itself.
-     *  2: Legacy + LSTM engines
-     *  3: Default, based on what is available
-     *
-     * As I didn't write the training data, and don't actually know what kind of network the training set requires, this value is set to default.
-     * </pre>
-     */
-    private static final int OCR_ENGINE_MODE = 3;
-
-    /**
-     * OCR language name, or training data filename.
-     */
-    private static final String OCR_LANGUAGE = "Pro6_temp_test";
-
-    /**
-     * Location on the file system that the OCR languages are stored.
-     *
-     * This value requires that the folder "tessdata" be in the same location as your current working directory. 
-     */
-    private static final String OCR_LANGUAGE_LOCATION = "tessdata";
-
-    static
-    {
-        api = new TessBaseAPI();
-        api.Init(OCR_LANGUAGE_LOCATION, OCR_LANGUAGE, OCR_ENGINE_MODE);
-    }
-
-    /** 
-     * Converts an image file to a double.
-     *
-     * @param file  File object of the image to be parsed by Tesseract.
-     * @return Double, as read from the image by Tesseract. Anomalous data returns Double.NEGATIVE_INFINITY
-     */
-    public static double imageToDouble(File file)
-    {
-        double output = Double.NEGATIVE_INFINITY;
-
-        PIX importedImage = pixRead(file.getAbsolutePath());
-        api.SetImage(importedImage);
-        String stringOutput = api.GetUTF8Text().getString();
-
-        if(!stringOutput.isEmpty())
-        {
-            try( Scanner sc = new Scanner(stringOutput.trim()); )
-            {
-                if(sc.hasNextDouble()) 
-                {
-                    output = sc.nextDouble();
-                    if(output >= 200) 
-                    {
-                        ErrorLogging.logError("OCR WARNING - OCR output is too high for DUT, attempting to adjust...");
-                        output = output / 10;
-                        if(output >= 300)
-                        {
-                            output = output / 10;
-                            ErrorLogging.logError("OCR output saved, as value appears to be real. Value needs to be verified.");
-                        }
-                        else if(output >= 200)  ErrorLogging.logError("OCR WARNING - OCR output is too high for DUT, potential misread.");
-                        else            ErrorLogging.logError("OCR output successfully adjusted. Disregard warning.");
-                    }
-                    if(output <= -10)   ErrorLogging.logError("OCR ERROR!!! - OCR output is too low  for DUT, potential misread.");
-                }
-                else ErrorLogging.logError("OCR ERROR!!! - OCR output is not a Double.");
-            }
-        }
-        else { ErrorLogging.logError("OCR Failed to retrieve information!"); }
-        return output;
-    }
-}

src/main/resources/logback.xml

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE configuration>
+
+<configuration>
+	<import class="ch.qos.logback.classic.encoder.PatternLayoutEncoder"/>
+	<import class="ch.qos.logback.core.FileAppender"/>
+	<import class="ch.qos.logback.core.ConsoleAppender"/>
+	<timestamp key="bySecond" datePattern="yyyy-MM-dd_HH.mm.ss" />
+	<timestamp key="printFile" datePattern="yyyy-MM-dd HH:mm:ss:SSSS" />
+
+	<appender name="FILE" class="FileAppender">
+		<!--<filter class="ch.qos.logback.classic.filter.LevelFilter">
+			<level>TRACE</level>
+			<onMatch>ACCEPT</onMatch>
+			<onMismatch>DENY</onMismatch>
+		</filter>-->
+		<file>logs/${bySecond}.log</file>
+		<encoder class="PatternLayoutEncoder">
+			<pattern>${printFile} - %level [%thread] %logger{10} [%file:%line] -%kvp- %msg%n</pattern>
+		</encoder>
+	</appender>
+
+	<appender name="STDOUT" class="ConsoleAppender">
+		<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+			<level>INFO</level>
+		</filter>
+		<encoder class="PatternLayoutEncoder">
+			<pattern>%level - %kvp %msg%n</pattern>
+		</encoder>
+	</appender>
+
+	<logger name="com.pi4j" level="WARN">
+	</logger>
+
+	<root level="TRACE">
+		<appender-ref ref="FILE"/>
+		<appender-ref ref="STDOUT"/>
+	</root>
+</configuration>

src/main/resources/simplelogger.properties

@@ -1,41 +0,0 @@
-# SLF4J's SimpleLogger configuration file
-# Simple implementation of Logger that sends all enabled log messages, for all defined loggers, to System.err.
-#The output target which can be the path to a file, or the special values "System.out" and "System.err". Default is "System.err".
-org.slf4j.simpleLogger.logFile=System.out
-
-# Default logging detail level for all instances of SimpleLogger.
-# Must be one of ("trace", "debug", "info", "warn", or "error").
-# If not specified, defaults to "info".
-org.slf4j.simpleLogger.defaultLogLevel=debug
-
-# Logging detail level for a SimpleLogger instance named "xxxxx".
-# Must be one of ("trace", "debug", "info", "warn", or "error").
-# If not specified, the default logging detail level is used.
-#org.slf4j.simpleLogger.log.xxxxx=
-#org.slf4j.simpleLogger.log.freemarker=debug
-#org.slf4j.simpleLogger.log.ro.pippo=debug
-#org.slf4j.simpleLogger.log.ro.fortsoft.matilda=debug
-
-# Set to true if you want the current date and time to be included in output messages.
-# Default is false, and will output the number of milliseconds elapsed since startup.
-#org.slf4j.simpleLogger.showDateTime=false
-org.slf4j.simpleLogger.showDateTime=true
-
-# The date and time format to be used in the output messages.
-# The pattern describing the date and time format is the same that is used in java.text.SimpleDateFormat.
-# If the format is not specified or is invalid, the default format is used.
-# The default format is yyyy-MM-dd HH:mm:ss:SSS Z.
-#org.slf4j.simpleLogger.dateTimeFormat=yyyy-MM-dd HH:mm:ss:SSS Z
-org.slf4j.simpleLogger.dateTimeFormat=HH:mm:ss
-
-# Set to true if you want to output the current thread name.
-# Defaults to true.
-#org.slf4j.simpleLogger.showThreadName=true
-
-# Set to true if you want the Logger instance name to be included in output messages.
-# Defaults to true.
-#org.slf4j.simpleLogger.showLogName=true
-
-# Set to true if you want the last component of the name to be included in output messages.
-# Defaults to false.
-#org.slf4j.simpleLogger.showShortLogName=false

toDoList.md

@@ -2,9 +2,14 @@
 
 ## High-priority fixes
 
-### OpenCVFacade
+### OutputFacade
+
+- [ ] Convert excel saving into two output files:
+	- Overview file (statistics, see commit d045e9d)
+	- File containing a list of all misread image names
+
+### ImageFacade
 
-- [x] Break out compose into a separate function
 - [ ] saveImage should have more robust file output checking
 
 ## Low-priority improvements