Add c-pchart from vendor as downloaded by composer

vendor/szymach/c-pchart/.gitignore

@@ -0,0 +1,24 @@
+# Created by http://www.gitignore.io
+
+### NetBeans ###
+nbproject
+nbproject/*
+nbproject/private/
+nbproject/project.properties
+nbproject/project.xml
+nbproject/private/private.xml
+nbproject/private/private.properties
+build/
+nbbuild/
+dist/
+nbdist/
+nbactions.xml
+nb-configuration.xml
+
+### vendor / web ###
+vendor/*
+web
+web/*
+
+### Composer ###
+composer.phar

vendor/szymach/c-pchart/.travis.yml

@@ -0,0 +1,16 @@
+language: php
+
+cache:
+  directories:
+    - vendor
+
+php:
+  - 5.4
+
+before_script:
+  - composer self-update -n
+  - composer install -n --prefer-dist -v
+
+after_failure:
+  - cat app/logs/dev.log
+  - cat app/logs/test.log

vendor/szymach/c-pchart/GPLv3.txt

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

vendor/szymach/c-pchart/LICENSE

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

vendor/szymach/c-pchart/README.md

@@ -0,0 +1,121 @@
+What is CpChart?
+===============
+
+A project bringing Composer support and some basic PHP 5 standards to pChart 2.0 library.
+The aim is to allow pChart integration into modern frameworks like Symfony2.
+
+What was done:
+
+- Made a full port of the library's functionality.
+
+- Defined and added namespaces to all classes.
+
+- Replaced all 'exit()' / 'die()' commands with 'throw' statements to allow a degree of error control.
+
+- Reorganized files a bit and refactored code for better readability. Also, basic annotations were added
+to functions.
+
+- Added a factory service for loading the classes.
+
+- Moved all constants to a single file 'src/Resources/data/constants.php'. This file is *required*
+for the library to function. It is now loaded via Composer.
+
+Installation:
+================
+
+[GitHub](https://github.com/szymach/c-pchart)
+
+[Packagist](https://packagist.org/packages/szymach/c-pchart)
+
+For composer installation, add:
+
+>"require": {
+
+> "szymach/c-pchart": "1.*"
+
+> },
+
+to your composer.json file and update your dependencies. After that, all
+classes are available under "CpChart\Classes" namespace or "CpChart\Services"
+for the factory.
+
+Usage:
+==============
+
+The main difference is that you can either load the class via the 'use' statement
+or use the provided factory. An example below. 
+
+```php
+require __DIR__.'/../vendor/autoload.php';
+
+use CpChart\Services\pChartFactory;
+
+try {
+    // create a factory class - it will load necessary files automatically,
+    // otherwise you will need to add them on your own
+    $factory = new pChartFactory();
+    
+    // create and populate the pData class
+    $myData = $factory->newData(array(VOID, 3, 4, 3, 5), "Serie1");
+
+    // create the image and set the data
+    $myPicture = $factory->newImage(700, 230, $myData);
+    $myPicture->setGraphArea(60, 40, 670, 190);
+    $myPicture->setFontProperties(
+        array(
+            "FontName" => "Forgotte.ttf",
+            "FontSize" => 11
+        )
+    );
+    
+    // creating a pie chart - notice that you specify the type of chart, not class name.
+    // not all charts need to be created through this method (ex. the bar chart),
+    // some are created via the pImage class (check the documentation before drawing).
+    $pieChart = $factory->newChart("pie", $myPicture, $myData);
+
+    // do the drawing
+    $myPicture->drawScale();
+    $myPicture->drawSplineChart();   
+    $myPicture->Stroke();
+
+} catch (\Exception $ex) {
+    echo 'There was an error: '.$ex->getMessage();
+}
+```
+
+Basically, it should work as defined in the pChart 2.0 documentation with added
+support for try/catch functionality. The factory class has methods to load all types of 
+classes present in the pChart library.
+
+IMPORTANT! If you want to use any of the fonts or palletes files, provide only
+the name of the actual file, do not add the 'fonts' or 'palettes' folder to the
+string given into the function. If you want to load them from a different directory
+than the default, you need to add the full path to the file (ex. __DIR__.'/folder/to/my/palletes).
+
+Changelog
+=========
+1.0 Stable version with basic functionality.
+
+1.1 Added factory service.
+
+1.1.1 Changed chart loading via factory a bit (see class annotations).
+
+1.1.2 Updated service class with Exception handling regarding missing / wrong class name.
+
+1.1.3 The file with classes' constants is now loaded via Composer (thanks to ThaDafinser).
+
+References
+==========
+[The original pChart website](http://www.pchart.net/)
+
+[Composer](https://getcomposer.org/)
+
+PHP Framework Interoperability Group at GitHub on PHP coding standards:
+
+[PSR-0](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md)
+
+[PSR-1](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-1-basic-coding-standard.md)
+
+[PSR-2](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-2-coding-style-guide.md)
+
+[PSR-4](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-4-autoloader.md)

vendor/szymach/c-pchart/composer.json

@@ -0,0 +1,17 @@
+{
+    "name": "szymach/c-pchart",
+    "license": "MIT",
+    "type": "project",
+    "description": "Port of \"pChart\" library into PHP 5.3.",
+    "keywords": ["pchart", "pChart","composer","statistics","charts", "c-pChart", "c-pchart"],
+    "homepage": "https://github.com/szymach/c-pchart",
+    "autoload": {
+        "psr-4": { "CpChart\\": "src/" },
+        "files": ["src/Resources/data/constants.php"]
+    },
+    "require": {
+        "php": ">=5.3.3",
+        "ext-gd": "*"
+    },
+    "version": "1.1.5"
+}

vendor/szymach/c-pchart/src/Classes/pBarcode128.php

@@ -0,0 +1,264 @@
+<?php
+namespace CpChart\Classes;
+
+ /*
+     pBarcode128 - class to create barcodes (128B)
+
+     Version     : 2.1.4
+     Made by     : Jean-Damien POGOLOTTI
+     Last Update : 19/01/2014
+
+     This file can be distributed under the license you can find at :
+
+                       http://www.pchart.net/license
+
+     You can find the whole class documentation on the pChart web site.
+ */
+
+ class pBarcode128
+{
+    public $Codes;
+    public $Reverse;
+    public $Result;
+    public $pChartObject;
+    public $CRC;
+
+    /**
+     * Class constructor
+     * 
+     * @param string $BasePath
+     * @throws \Exception
+     */
+    public function __construct($BasePath = "")
+    {
+        $this->Codes   = "";
+        $this->Reverse = "";
+        if (file_exists($BasePath."data/128B.db", "r")) {
+            $FileHandle = @fopen($BasePath."data/128B.db", "r");
+            $filePath = $BasePath."data/128B.db";
+        } else {
+            $FileHandle = @fopen(__DIR__.'/../Resources/data/128B.db', "r");
+            $filePath = "/../Resources/data/128B.db";            
+        }
+        
+        if (!$FileHandle) { 
+            throw new \Exception(
+                "Cannot find barcode database (".$filePath.")."
+            );
+        }
+
+        while (!feof($FileHandle)) {
+            $Buffer = fgets($FileHandle,4096);
+            $Buffer = str_replace(chr(10),"",$Buffer);
+            $Buffer = str_replace(chr(13),"",$Buffer);
+            $Values = preg_split("/;/",$Buffer);
+
+            $this->Codes[$Values[1]]["ID"]     = $Values[0];
+            $this->Codes[$Values[1]]["Code"]   = $Values[2];
+            $this->Reverse[$Values[0]]["Code"] = $Values[2];
+            $this->Reverse[$Values[0]]["Asc"]  = $Values[1];
+        }
+        fclose($FileHandle);
+    }
+
+    /**
+     * Return the projected size of a barcode
+     * 
+     * @param type $TextString
+     * @param type $Format
+     * @return array
+     */
+    public function getSize($TextString, $Format = "")
+    {
+        $Angle		= isset($Format["Angle"]) ? $Format["Angle"] : 0;
+        $ShowLegend	= isset($Format["ShowLegend"]) 
+                          ? $Format["ShowLegend"] : false;
+        $LegendOffset	= isset($Format["LegendOffset"]) 
+                          ? $Format["LegendOffset"] : 5;
+        $DrawArea	= isset($Format["DrawArea"]) 
+                          ? $Format["DrawArea"] : false;
+        $FontSize	= isset($Format["FontSize"]) 
+                          ? $Format["FontSize"] : 12;
+        $Height		= isset($Format["Height"]) 
+                          ? $Format["Height"] : 30;
+
+        $TextString    = $this->encode128($TextString);
+        $BarcodeLength = strlen($this->Result);
+
+        $WOffset = $DrawArea ? 20 : 0; 
+        $HOffset = $ShowLegend ? $FontSize + $LegendOffset + $WOffset : 0;
+
+        $X1 = cos($Angle * PI / 180) * ($WOffset+$BarcodeLength);
+        $Y1 = sin($Angle * PI / 180) * ($WOffset+$BarcodeLength);
+
+        $X2 = $X1 + cos(($Angle+90) * PI / 180) * ($HOffset+$Height);
+        $Y2 = $Y1 + sin(($Angle+90) * PI / 180) * ($HOffset+$Height);
+
+
+        $AreaWidth  = max(abs($X1), abs($X2));
+        $AreaHeight = max(abs($Y1), abs($Y2));
+
+        return(array("Width" => $AreaWidth, "Height" => $AreaHeight));
+    }
+
+    /**
+     * 
+     * @param type $Value
+     * @param type $Format
+     * @return string
+     */
+    public function encode128($Value, $Format = "")
+    {
+        $this->Result  = "11010010000";
+        $this->CRC     = 104;
+        $TextString    = "";
+
+        for ($i=1; $i <= strlen($Value); $i++) {
+            $CharCode = ord($this->mid($Value,$i,1));
+            if ( isset($this->Codes[$CharCode]) ) {
+                $this->Result = $this->Result.$this->Codes[$CharCode]["Code"];
+                $this->CRC = $this->CRC + $i*$this->Codes[$CharCode]["ID"];
+                $TextString = $TextString.chr($CharCode);
+             }
+         }
+        $this->CRC = $this->CRC - floor($this->CRC/103)*103;
+
+        $this->Result = $this->Result.$this->Reverse[$this->CRC]["Code"];
+        $this->Result = $this->Result."1100011101011";
+
+        return($TextString);
+    }
+
+    /**
+     * Create the encoded string
+     * @param type $Object
+     * @param type $Value
+     * @param type $X
+     * @param type $Y
+     * @param type $Format
+     */
+    public function draw($Object, $Value, $X, $Y, $Format = "")
+    {
+        $this->pChartObject = $Object;
+
+        $R		= isset($Format["R"]) ? $Format["R"] : 0;
+        $G		= isset($Format["G"]) ? $Format["G"] : 0;
+        $B		= isset($Format["B"]) ? $Format["B"] : 0;
+        $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
+        $Height		= isset($Format["Height"]) ? $Format["Height"] : 30;
+        $Angle		= isset($Format["Angle"]) ? $Format["Angle"] : 0;
+        $ShowLegend	= isset($Format["ShowLegend"]) 
+                          ? $Format["ShowLegend"] : false;
+        $LegendOffset	= isset($Format["LegendOffset"]) 
+                          ? $Format["LegendOffset"] : 5;
+        $DrawArea		= isset($Format["DrawArea"]) 
+                          ? $Format["DrawArea"] : false;
+        $AreaR		= isset($Format["AreaR"]) ? $Format["AreaR"] : 255;
+        $AreaG		= isset($Format["AreaG"]) ? $Format["AreaG"] : 255;
+        $AreaB		= isset($Format["AreaB"]) ? $Format["AreaB"] : 255;
+        $AreaBorderR	= isset($Format["AreaBorderR"]) 
+                          ? $Format["AreaBorderR"] : $AreaR;
+        $AreaBorderG	= isset($Format["AreaBorderG"]) 
+                          ? $Format["AreaBorderG"] : $AreaG;
+        $AreaBorderB	= isset($Format["AreaBorderB"]) 
+                          ? $Format["AreaBorderB"] : $AreaB;
+
+        $TextString = $this->encode128($Value);
+
+        if ($DrawArea) {
+            $X1 = $X + cos(($Angle-135) * PI / 180) * 10;
+            $Y1 = $Y + sin(($Angle-135) * PI / 180) * 10;
+
+            $X2 = $X1 + cos($Angle * PI / 180) * (strlen($this->Result)+20);
+            $Y2 = $Y1 + sin($Angle * PI / 180) * (strlen($this->Result)+20);
+
+            if ($ShowLegend) {
+                $X3 = $X2 + cos(($Angle+90) * PI / 180) 
+                    * ($Height + $LegendOffset + $this->pChartObject->FontSize + 10);
+                $Y3 = $Y2 + sin(($Angle+90) * PI / 180) 
+                    * ($Height + $LegendOffset + $this->pChartObject->FontSize  +10);
+            } else {
+                $X3 = $X2 + cos(($Angle+90) * PI / 180) * ($Height+20);
+                $Y3 = $Y2 + sin(($Angle+90) * PI / 180) * ($Height+20);
+            }
+
+            $X4 = $X3 + cos(($Angle+180) * PI / 180) * (strlen($this->Result) + 20);
+            $Y4 = $Y3 + sin(($Angle+180) * PI / 180) * (strlen($this->Result) + 20);
+
+            $Polygon  = array($X1, $Y1, $X2, $Y2, $X3, $Y3, $X4, $Y4);
+            $Settings = array(
+                "R" => $AreaR,
+                "G" => $AreaG,
+                "B" => $AreaB,
+                "BorderR" => $AreaBorderR,
+                "BorderG" => $AreaBorderG,
+                "BorderB" => $AreaBorderB
+            );
+            $this->pChartObject->drawPolygon($Polygon,$Settings);
+        }
+
+        for ($i=1; $i<=strlen($this->Result); $i++) {
+            if ($this->mid($this->Result, $i, 1) == 1) {
+                $X1 = $X + cos($Angle * PI / 180) * $i;
+                $Y1 = $Y + sin($Angle * PI / 180) * $i;
+                $X2 = $X1 + cos(($Angle+90) * PI / 180) * $Height;
+                $Y2 = $Y1 + sin(($Angle+90) * PI / 180) * $Height;
+
+                $Settings = array("R" => $R, "G" => $G, "B" => $B,"Alpha" => $Alpha);
+                $this->pChartObject->drawLine($X1,$Y1,$X2,$Y2,$Settings);
+            }
+        }
+
+        if ($ShowLegend) {
+            $X1 = $X + cos($Angle * PI / 180) * (strlen($this->Result)/2);
+            $Y1 = $Y + sin($Angle * PI / 180) * (strlen($this->Result)/2);
+
+            $LegendX = $X1 + cos(($Angle+90) * PI / 180) * ($Height+$LegendOffset);
+            $LegendY = $Y1 + sin(($Angle+90) * PI / 180) * ($Height+$LegendOffset);
+
+            $Settings = array(
+                "R" => $R,
+                "G" => $G,
+                "B" => $B,
+                "Alpha" => $Alpha,
+                "Angle" => -$Angle,
+                "Align" => TEXT_ALIGN_TOPMIDDLE
+            );
+            $this->pChartObject->drawText($LegendX,$LegendY,$TextString,$Settings);
+        }
+    }
+
+    /**
+     * 
+     * @param type $value
+     * @param type $NbChar
+     * @return string
+     */
+    public function left($value, $NbChar)
+    {
+        return substr($value, 0, $NbChar);         
+    }  
+    /**
+     * 
+     * @param type $value
+     * @param type $NbChar
+     * @return type
+     */
+    public function right($value, $NbChar) 
+    {
+        return substr($value, strlen($value) - $NbChar, $NbChar);         
+    } 
+    
+    /**
+     * 
+     * @param type $value
+     * @param type $Depart
+     * @param type $NbChar
+     * @return type
+     */
+    public function mid($value, $Depart, $NbChar) 
+    { 
+        return substr($value, $Depart - 1, $NbChar);         
+    }  
+    
+}

vendor/szymach/c-pchart/src/Classes/pBarcode39.php

@@ -0,0 +1,247 @@
+<?php
+namespace CpChart\Classes;
+
+/*
+    pBarcode39 - class to create barcodes (39B)
+
+    Version     : 2.1.4
+    Made by     : Jean-Damien POGOLOTTI
+    Last Update : 19/01/2014
+
+    This file can be distributed under the license you can find at :
+
+                      http://www.pchart.net/license
+
+    You can find the whole class documentation on the pChart web site.
+*/
+class pBarcode39
+{
+    public $Codes;
+    public $Reverse;
+    public $Result;
+    public $pChartObject;
+    public $CRC;
+    public $MOD43;
+
+    /**
+     * Class constructor
+     * @param type $BasePath
+     * @param type $EnableMOD43
+     * @throws \Exception
+     */
+    function __construct($BasePath = "", $EnableMOD43 = false)
+    {
+        $this->MOD43   = $EnableMOD43;
+        $this->Codes   = "";
+        $this->Reverse = "";
+        if (file_exists($BasePath."data/39.db", "r")) {
+            $FileHandle = @fopen($BasePath."data/39.db", "r");
+            $filePath = $BasePath."data/39.db";
+        } else {
+            $FileHandle = @fopen(__DIR__.'/../Resources/data/39.db', "r");
+            $filePath = "/../Resources/data/39.db";            
+        }
+
+        if (!$FileHandle) { 
+            throw new \Exception(
+                "Cannot find barcode database (".$filePath.")."
+            );
+        }
+
+        while (!feof($FileHandle)) {
+            $Buffer = fgets($FileHandle, 4096);
+            $Buffer = str_replace(chr(10), "", $Buffer);
+            $Buffer = str_replace(chr(13), "", $Buffer);
+            $Values = preg_split("/;/", $Buffer);
+
+            $this->Codes[$Values[0]] = $Values[1];
+        }
+        fclose($FileHandle);
+    }
+
+    /**
+     * Return the projected size of a barcode
+     * @param type $TextString
+     * @param type $Format
+     * @return type
+     */
+    function getSize($TextString, $Format = "")
+    {
+        $Angle		= isset($Format["Angle"]) ? $Format["Angle"] : 0;
+        $ShowLegend	= isset($Format["ShowLegend"]) ? $Format["ShowLegend"] : false;
+        $LegendOffset	= isset($Format["LegendOffset"]) ? $Format["LegendOffset"] : 5;
+        $DrawArea	= isset($Format["DrawArea"]) ? $Format["DrawArea"] : false;
+        $FontSize	= isset($Format["FontSize"]) ? $Format["FontSize"] : 12;
+        $Height		= isset($Format["Height"]) ? $Format["Height"] : 30;
+
+        $TextString    = $this->encode39($TextString);
+        $BarcodeLength = strlen($this->Result);
+        
+        $WOffset = $DrawArea ? 20 : 0 ;
+        $HOffset = $ShowLegend ? $FontSize + $LegendOffset + $WOffset : 0;
+
+        $X1 = cos($Angle * PI / 180) * ($WOffset + $BarcodeLength);
+        $Y1 = sin($Angle * PI / 180) * ($WOffset + $BarcodeLength);
+
+        $X2 = $X1 + cos(($Angle+90) * PI / 180) * ($HOffset+$Height);
+        $Y2 = $Y1 + sin(($Angle+90) * PI / 180) * ($HOffset+$Height);
+
+
+        $AreaWidth  = max(abs($X1),abs($X2));
+        $AreaHeight = max(abs($Y1),abs($Y2));
+
+        return(array("Width" => $AreaWidth, "Height" => $AreaHeight));
+    }
+
+    /**
+     * Create the encoded string
+     * @param type $Value
+     * @return string
+     */
+    function encode39($Value)
+    {
+        $this->Result = "100101101101"."0";
+        $TextString   = "";
+        for ($i=1; $i <= strlen($Value); $i++) {
+            $CharCode = ord($this->mid($Value,$i,1));
+            if ($CharCode >= 97 && $CharCode <= 122) { 
+                $CharCode = $CharCode - 32;                 
+            }
+
+            if (isset($this->Codes[chr($CharCode)])) {
+                $this->Result = $this->Result.$this->Codes[chr($CharCode)]."0";
+                $TextString = $TextString.chr($CharCode);
+            }
+        }
+
+        if ($this->MOD43) {
+            $Checksum = $this->checksum($TextString);
+            $this->Result = $this->Result.$this->Codes[$Checksum]."0";
+        }
+
+        $this->Result = $this->Result."100101101101";
+        $TextString   = "*".$TextString."*";
+
+        return $TextString;
+    }
+
+    /**
+     * Create the encoded string
+     * @param type $Object
+     * @param type $Value
+     * @param type $X
+     * @param type $Y
+     * @param type $Format
+     */
+    function draw($Object,$Value,$X,$Y,$Format="")
+    {
+        $this->pChartObject = $Object;
+
+        $R		= isset($Format["R"]) ? $Format["R"] : 0;
+        $G		= isset($Format["G"]) ? $Format["G"] : 0;
+        $B		= isset($Format["B"]) ? $Format["B"] : 0;
+        $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
+        $Height		= isset($Format["Height"]) ? $Format["Height"] : 30;
+        $Angle		= isset($Format["Angle"]) ? $Format["Angle"] : 0;
+        $ShowLegend	= isset($Format["ShowLegend"]) ? $Format["ShowLegend"] : false;
+        $LegendOffset	= isset($Format["LegendOffset"]) ? $Format["LegendOffset"] : 5;
+        $DrawArea	= isset($Format["DrawArea"]) ? $Format["DrawArea"] : false;
+        $AreaR		= isset($Format["AreaR"]) ? $Format["AreaR"] : 255;
+        $AreaG		= isset($Format["AreaG"]) ? $Format["AreaG"] : 255;
+        $AreaB		= isset($Format["AreaB"]) ? $Format["AreaB"] : 255;
+        $AreaBorderR	= isset($Format["AreaBorderR"]) ? $Format["AreaBorderR"] : $AreaR;
+        $AreaBorderG	= isset($Format["AreaBorderG"]) ? $Format["AreaBorderG"] : $AreaG;
+        $AreaBorderB	= isset($Format["AreaBorderB"]) ? $Format["AreaBorderB"] : $AreaB;
+
+        $TextString   = $this->encode39($Value);
+
+        if ($DrawArea) {
+            $X1 = $X + cos(($Angle-135) * PI / 180) * 10;
+            $Y1 = $Y + sin(($Angle-135) * PI / 180) * 10;
+
+            $X2 = $X1 + cos($Angle * PI / 180) * (strlen($this->Result)+20);
+            $Y2 = $Y1 + sin($Angle * PI / 180) * (strlen($this->Result)+20);
+
+            if ($ShowLegend) {
+                $X3 = $X2 + cos(($Angle+90) * PI / 180) 
+                    * ($Height+$LegendOffset+$this->pChartObject->FontSize+10);
+                $Y3 = $Y2 + sin(($Angle+90) * PI / 180) 
+                    * ($Height+$LegendOffset+$this->pChartObject->FontSize+10);
+            } else {
+                $X3 = $X2 + cos(($Angle+90) * PI / 180) * ($Height+20);
+                $Y3 = $Y2 + sin(($Angle+90) * PI / 180) * ($Height+20);
+            }
+
+            $X4 = $X3 + cos(($Angle+180) * PI / 180) * (strlen($this->Result)+20);
+            $Y4 = $Y3 + sin(($Angle+180) * PI / 180) * (strlen($this->Result)+20);
+
+            $Polygon  = array($X1, $Y1, $X2, $Y2, $X3, $Y3, $X4, $Y4);
+            $Settings = array(
+                "R" => $AreaR,
+                "G" => $AreaG,
+                "B" =>$AreaB,
+                "BorderR" => $AreaBorderR,
+                "BorderG" => $AreaBorderG,
+                "BorderB" => $AreaBorderB
+            );
+            $this->pChartObject->drawPolygon($Polygon,$Settings);
+        }
+
+        for ($i=1; $i <= strlen($this->Result); $i++) {
+            if ($this->mid($this->Result,$i,1) == 1) {
+                $X1 = $X + cos($Angle * PI / 180) * $i;
+                $Y1 = $Y + sin($Angle * PI / 180) * $i;
+                $X2 = $X1 + cos(($Angle+90) * PI / 180) * $Height;
+                $Y2 = $Y1 + sin(($Angle+90) * PI / 180) * $Height;
+
+                $Settings = array("R" => $R, "G" => $G, "B" => $B, "Alpha" => $Alpha);
+                $this->pChartObject->drawLine($X1, $Y1, $X2, $Y2, $Settings);
+            }
+        }
+
+        if ($ShowLegend) {
+            $X1 = $X + cos($Angle * PI / 180) * (strlen($this->Result)/2);
+            $Y1 = $Y + sin($Angle * PI / 180) * (strlen($this->Result)/2);
+
+            $LegendX = $X1 + cos(($Angle+90) * PI / 180) * ($Height+$LegendOffset);
+            $LegendY = $Y1 + sin(($Angle+90) * PI / 180) * ($Height+$LegendOffset);
+
+            $Settings = array(
+                "R" => $R,
+                "G" => $G,
+                "B" => $B,
+                "Alpha" => $Alpha,
+                "Angle" => -$Angle,
+                "Align" => TEXT_ALIGN_TOPMIDDLE
+            );
+            $this->pChartObject->drawText($LegendX, $LegendY, $TextString, $Settings);
+        }
+    }
+
+    function checksum($string)
+    {
+        $checksum = 0;
+        $length   = strlen($string);
+        $charset  = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%';
+
+        for( $i=0; $i < $length; ++$i ) {
+            $checksum += strpos( $charset, $string[$i] );
+        }
+        return substr( $charset, ($checksum % 43), 1 );
+    }
+
+    function left($value, $NbChar)
+    { 
+        return substr($value, 0, $NbChar);         
+    }  
+    
+    function right($value, $NbChar) 
+    { 
+        return substr($value, strlen($value) - $NbChar, $NbChar);
+    }  
+    
+    function mid($value, $Depart, $NbChar)
+    { 
+        return substr($value, $Depart-1, $NbChar);         
+    }  
+}

vendor/szymach/c-pchart/src/Classes/pBubble.php

@@ -0,0 +1,463 @@
+<?php
+namespace CpChart\Classes;
+
+/*
+    pBubble - class to draw bubble charts
+
+    Version     : 2.1.4
+    Made by     : Jean-Damien POGOLOTTI
+    Last Update : 19/01/2014
+
+    This file can be distributed under the license you can find at :
+
+                      http://www.pchart.net/license
+
+    You can find the whole class documentation on the pChart web site.
+*/
+class pBubble
+{
+    public $pChartObject;
+    public $pDataObject;
+
+    public function __construct($pChartObject, $pDataObject)
+    {
+        $this->pChartObject = $pChartObject;
+        $this->pDataObject  = $pDataObject;
+    }
+
+    /* Prepare the scale */
+    public function bubbleScale($DataSeries,$WeightSeries)
+    {
+        if (!is_array($DataSeries)) { 
+            $DataSeries = array($DataSeries);         
+        }
+        if (!is_array($WeightSeries)) { 
+            $WeightSeries = array($WeightSeries);         
+        }
+
+        /* Parse each data series to find the new min & max boundaries to scale */
+        $NewPositiveSerie = ""; 
+        $NewNegativeSerie = ""; 
+        $MaxValues = 0; 
+        $LastPositive = 0; 
+        $LastNegative = 0;
+    
+        foreach($DataSeries as $Key => $SerieName) {
+            $SerieWeightName = $WeightSeries[$Key];
+
+            $this->pDataObject->setSerieDrawable($SerieWeightName,false);
+
+            if (count(
+                    $this->pDataObject->Data["Series"][$SerieName]["Data"]
+                ) > $MaxValues
+            ) { 
+                $MaxValues = count($this->pDataObject->Data["Series"][$SerieName]["Data"]);         
+            }
+
+            foreach($this->pDataObject->Data["Series"][$SerieName]["Data"] 
+                    as $Key => $Value
+            ) {
+                if ($Value >= 0) {
+                    $BubbleBounds = $Value + $this->pDataObject->Data["Series"][$SerieWeightName]["Data"][$Key];
+
+                    if ( !isset($NewPositiveSerie[$Key]) ) { 
+                        $NewPositiveSerie[$Key] = $BubbleBounds;                     
+                    } elseif ($NewPositiveSerie[$Key] < $BubbleBounds) { 
+                        $NewPositiveSerie[$Key] = $BubbleBounds;                     
+                    }
+                    $LastPositive = $BubbleBounds;
+                } else {
+                    $BubbleBounds = $Value - $this->pDataObject->Data["Series"][$SerieWeightName]["Data"][$Key];
+
+                    if (!isset($NewNegativeSerie[$Key])) { 
+                        $NewNegativeSerie[$Key] = $BubbleBounds;                     
+                    } elseif ($NewNegativeSerie[$Key] > $BubbleBounds) { 
+                        $NewNegativeSerie[$Key] = $BubbleBounds;                     
+                    }
+                    $LastNegative = $BubbleBounds;
+                }
+            }
+        }
+
+        /* Check for missing values and all the fake positive serie */
+        if ( $NewPositiveSerie != "" ) {
+            for ($i=0; $i<$MaxValues; $i++) { 
+                if (!isset($NewPositiveSerie[$i])) { 
+                    $NewPositiveSerie[$i] = $LastPositive;             
+                }             
+            }
+            $this->pDataObject->addPoints($NewPositiveSerie,"BubbleFakePositiveSerie");
+        }
+
+        /* Check for missing values and all the fake negative serie */
+        if ( $NewNegativeSerie != "" ) {
+            for ($i = 0; $i < $MaxValues; $i++) {
+                if (!isset($NewNegativeSerie[$i])) { 
+                    $NewNegativeSerie[$i] = $LastNegative;             
+                }
+            }
+
+            $this->pDataObject->addPoints($NewNegativeSerie,"BubbleFakeNegativeSerie");
+        }
+    }
+
+    public function resetSeriesColors()
+    {
+        $Data    = $this->pDataObject->getData();
+        $Palette = $this->pDataObject->getPalette();
+
+        $ID = 0;
+        foreach($Data["Series"] as $SerieName => $SeriesParameters) {
+            if ( $SeriesParameters["isDrawable"] ) {
+                $this->pDataObject->Data["Series"][$SerieName]["Color"]["R"]     = $Palette[$ID]["R"];
+                $this->pDataObject->Data["Series"][$SerieName]["Color"]["G"]     = $Palette[$ID]["G"];
+                $this->pDataObject->Data["Series"][$SerieName]["Color"]["B"]     = $Palette[$ID]["B"];
+                $this->pDataObject->Data["Series"][$SerieName]["Color"]["Alpha"] = $Palette[$ID]["Alpha"];
+                $ID++;
+            }
+        }
+    }
+
+    /* Prepare the scale */
+    public function drawBubbleChart($DataSeries, $WeightSeries, $Format="")
+    {
+        $ForceAlpha	= isset($Format["ForceAlpha"]) ? $Format["ForceAlpha"] : VOID;
+        $DrawBorder	= isset($Format["DrawBorder"]) ? $Format["DrawBorder"] : TRUE;
+        $BorderWidth	= isset($Format["BorderWidth"]) ? $Format["BorderWidth"] : 1;
+        $Shape		= isset($Format["Shape"]) ? $Format["Shape"] : BUBBLE_SHAPE_ROUND;
+        $Surrounding	= isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;
+        $BorderR	= isset($Format["BorderR"]) ? $Format["BorderR"] : 0;
+        $BorderG	= isset($Format["BorderG"]) ? $Format["BorderG"] : 0;
+        $BorderB	= isset($Format["BorderB"]) ? $Format["BorderB"] : 0;
+        $BorderAlpha	= isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : 30;
+        $RecordImageMap	= isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : false;
+
+        if (!is_array($DataSeries)) {
+            $DataSeries = array($DataSeries);             
+        }
+        if (!is_array($WeightSeries)) { 
+            $WeightSeries = array($WeightSeries);
+        }
+
+        $Data    = $this->pDataObject->getData();
+        $Palette = $this->pDataObject->getPalette();
+
+        if (isset($Data["Series"]["BubbleFakePositiveSerie"])) { 
+            $this->pDataObject->setSerieDrawable("BubbleFakePositiveSerie",false);
+        }
+        if (isset($Data["Series"]["BubbleFakeNegativeSerie"])) { 
+            $this->pDataObject->setSerieDrawable("BubbleFakeNegativeSerie",false);         
+        }
+
+        $this->resetSeriesColors();
+
+        list($XMargin,$XDivs) = $this->pChartObject->scaleGetXSettings();
+
+        foreach($DataSeries as $Key => $SerieName) {
+            $AxisID	= $Data["Series"][$SerieName]["Axis"];
+            $Mode	= $Data["Axis"][$AxisID]["Display"];
+            $Format	= $Data["Axis"][$AxisID]["Format"];
+            $Unit	= $Data["Axis"][$AxisID]["Unit"];
+
+            if (isset($Data["Series"][$SerieName]["Description"])) {
+                $SerieDescription = $Data["Series"][$SerieName]["Description"];             
+            } else { 
+                $SerieDescription = $SerieName;             
+            }
+
+            $XStep = ($this->pChartObject->GraphAreaX2 - $this->pChartObject->GraphAreaX1 - $XMargin*2)/$XDivs;
+
+            $X = $this->pChartObject->GraphAreaX1 + $XMargin;
+            $Y = $this->pChartObject->GraphAreaY1 + $XMargin;
+
+            $Color = array(
+                "R" => $Palette[$Key]["R"],
+                "G" => $Palette[$Key]["G"],
+                "B" => $Palette[$Key]["B"],
+                "Alpha" => $Palette[$Key]["Alpha"]
+            );
+
+            if ( $ForceAlpha != VOID ) {
+                $Color["Alpha"] = $ForceAlpha;                 
+            }
+
+            if ($DrawBorder) {
+                if ( $BorderWidth != 1 ) {
+                    if ( $Surrounding != NULL ) { 
+                        $BorderR = $Palette[$Key]["R"]+$Surrounding; 
+                        $BorderG = $Palette[$Key]["G"]+$Surrounding; 
+                        $BorderB = $Palette[$Key]["B"]+$Surrounding;
+                    } else { 
+                        $BorderR = $BorderR; 
+                        $BorderG = $BorderG; 
+                        $BorderB = $BorderB;                         
+                    }
+                    if ( $ForceAlpha != VOID ) { 
+                        $BorderAlpha = $ForceAlpha/2;                         
+                    }
+                    $BorderColor = array(
+                        "R"=>$BorderR,
+                        "G"=>$BorderG,
+                        "B"=>$BorderB,
+                        "Alpha"=>$BorderAlpha
+                    );
+                } else {
+                    $Color["BorderAlpha"] = $BorderAlpha;
+
+                    if ( $Surrounding != NULL ) { 
+                        $Color["BorderR"] = $Palette[$Key]["R"]+$Surrounding; 
+                        $Color["BorderG"] = $Palette[$Key]["G"]+$Surrounding; 
+                        $Color["BorderB"] = $Palette[$Key]["B"]+$Surrounding;                         
+                    } else { 
+                        $Color["BorderR"] = $BorderR; 
+                        $Color["BorderG"] = $BorderG; 
+                        $Color["BorderB"] = $BorderB;                         
+                    }
+                    if ( $ForceAlpha != VOID ) {
+                        $Color["BorderAlpha"] = $ForceAlpha/2;                         
+                    }
+                }
+            }
+
+            foreach($Data["Series"][$SerieName]["Data"] as $iKey => $Point) {
+                $Weight = $Point + $Data["Series"][$WeightSeries[$Key]]["Data"][$iKey];
+
+                $PosArray = $this->pChartObject->scaleComputeY(
+                    $Point,
+                    array("AxisID"=>$AxisID)
+                );
+                $WeightArray = $this->pChartObject->scaleComputeY(
+                    $Weight,
+                    array("AxisID"=>$AxisID)
+                );
+
+                if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT ) {
+                    if ( $XDivs == 0 ) { 
+                        $XStep = 0;                         
+                    } else { 
+                        $XStep = ($this->pChartObject->GraphAreaX2 - $this->pChartObject->GraphAreaX1-$XMargin*2)/$XDivs;                         
+                    }
+                    $Y = floor($PosArray); $CircleRadius = floor(abs($PosArray - $WeightArray)/2);
+
+                    if ( $Shape == BUBBLE_SHAPE_SQUARE ) {
+                        if ( $RecordImageMap ) { 
+                            $this->pChartObject->addToImageMap(
+                                "RECT",
+                                (
+                                    floor($X-$CircleRadius)
+                                    .",".floor($Y-$CircleRadius)
+                                    .",".floor($X+$CircleRadius)
+                                    .",".floor($Y+$CircleRadius)
+                                ),
+                                $this->pChartObject->toHTMLColor($Palette[$Key]["R"],
+                                $Palette[$Key]["G"],$Palette[$Key]["B"]),
+                                $SerieDescription,$Data["Series"][$WeightSeries[$Key]]["Data"][$iKey]
+                            );                             
+                        }
+
+                        if ( $BorderWidth != 1 ) {
+                            $this->pChartObject->drawFilledRectangle(
+                                $X-$CircleRadius-$BorderWidth,
+                                $Y-$CircleRadius-$BorderWidth,
+                                $X+$CircleRadius+$BorderWidth,
+                                $Y+$CircleRadius+$BorderWidth,
+                                $BorderColor
+                            );
+                            $this->pChartObject->drawFilledRectangle(
+                                $X-$CircleRadius,
+                                $Y-$CircleRadius,
+                                $X+$CircleRadius,
+                                $Y+$CircleRadius,
+                                $Color
+                            );
+                        } else {
+                            $this->pChartObject->drawFilledRectangle(
+                                $X-$CircleRadius,
+                                $Y-$CircleRadius,
+                                $X+$CircleRadius,
+                                $Y+$CircleRadius,
+                                $Color
+                            );
+                        }
+                    } elseif ( $Shape == BUBBLE_SHAPE_ROUND ) {
+                        if ( $RecordImageMap ) {
+                            $this->pChartObject->addToImageMap(
+                                "CIRCLE",
+                                floor($X).",".floor($Y).",".floor($CircleRadius),
+                                $this->pChartObject->toHTMLColor($Palette[$Key]["R"],
+                                $Palette[$Key]["G"],
+                                $Palette[$Key]["B"]),
+                                $SerieDescription,$Data["Series"][$WeightSeries[$Key]]["Data"][$iKey]
+                            );                             
+                        }
+
+                        if ( $BorderWidth != 1 ) {
+                            $this->pChartObject->drawFilledCircle($X,$Y,$CircleRadius+$BorderWidth,$BorderColor);
+                            $this->pChartObject->drawFilledCircle($X,$Y,$CircleRadius,$Color);
+                        } else {
+                            $this->pChartObject->drawFilledCircle($X,$Y,$CircleRadius,$Color);
+                        }
+                    }
+
+                    $X = $X + $XStep;
+                } elseif ( $Data["Orientation"] == SCALE_POS_TOPBOTTOM ) {
+                    if ( $XDivs == 0 ) { 
+                        $XStep = 0;                         
+                    } else { 
+                        $XStep = ($this->pChartObject->GraphAreaY2-$this->pChartObject->GraphAreaY1-$XMargin*2)/$XDivs;
+                    }
+                    $X = floor($PosArray); $CircleRadius = floor(abs($PosArray - $WeightArray)/2);
+
+                    if ( $Shape == BUBBLE_SHAPE_SQUARE ) {
+                        if ( $RecordImageMap ) { 
+                            $this->pChartObject->addToImageMap(
+                                "RECT",
+                                floor($X-$CircleRadius).",".floor($Y-$CircleRadius).",".floor($X+$CircleRadius).",".floor($Y+$CircleRadius),
+                                $this->pChartObject->toHTMLColor($Palette[$Key]["R"],$Palette[$Key]["G"],$Palette[$Key]["B"]),
+                                $SerieDescription,$Data["Series"][$WeightSeries[$Key]]["Data"][$iKey]
+                            );                             
+                        }
+
+                        if ( $BorderWidth != 1 ) {
+                            $this->pChartObject->drawFilledRectangle($X-$CircleRadius-$BorderWidth,$Y-$CircleRadius-$BorderWidth,$X+$CircleRadius+$BorderWidth,$Y+$CircleRadius+$BorderWidth,$BorderColor);
+                            $this->pChartObject->drawFilledRectangle($X-$CircleRadius,$Y-$CircleRadius,$X+$CircleRadius,$Y+$CircleRadius,$Color);
+                        } else {
+                            $this->pChartObject->drawFilledRectangle($X-$CircleRadius,$Y-$CircleRadius,$X+$CircleRadius,$Y+$CircleRadius,$Color);
+                        }
+                    } elseif ( $Shape == BUBBLE_SHAPE_ROUND ) {
+                        if ( $RecordImageMap ) { 
+                            $this->pChartObject->addToImageMap(
+                                "CIRCLE",
+                                floor($X).",".floor($Y).",".floor($CircleRadius),
+                                $this->pChartObject->toHTMLColor($Palette[$Key]["R"],$Palette[$Key]["G"],$Palette[$Key]["B"]),
+                                $SerieDescription,$Data["Series"][$WeightSeries[$Key]]["Data"][$iKey]
+                            );
+                        }
+
+                        if ( $BorderWidth != 1 ) {
+                            $this->pChartObject->drawFilledCircle($X,$Y,$CircleRadius+$BorderWidth,$BorderColor);
+                            $this->pChartObject->drawFilledCircle($X,$Y,$CircleRadius,$Color);
+                        } else {
+                            $this->pChartObject->drawFilledCircle($X,$Y,$CircleRadius,$Color);
+                        }
+                    }
+
+                    $Y = $Y + $XStep;
+                }
+            }
+        }
+    }
+
+    public function writeBubbleLabel($SerieName,$SerieWeightName,$Points,$Format="")
+    {
+        $OverrideTitle	= isset($Format["OverrideTitle"]) ? $Format["OverrideTitle"] : NULL;
+        $DrawPoint      = isset($Format["DrawPoint"]) ? $Format["DrawPoint"] : LABEL_POINT_BOX;
+
+        if ( !is_array($Points) ) { 
+            $Point = $Points; 
+            $Points = ""; 
+            $Points[] = $Point;             
+        }
+
+        $Data    = $this->pDataObject->getData();
+        $Palette = $this->pDataObject->getPalette();
+
+        if (!isset($Data["Series"][$SerieName]) 
+            || !isset($Data["Series"][$SerieWeightName]) 
+        ) {
+            return(0);
+        }
+        list($XMargin,$XDivs) = $this->pChartObject->scaleGetXSettings();
+
+        $AxisID	    = $Data["Series"][$SerieName]["Axis"];
+        $AxisMode   = $Data["Axis"][$AxisID]["Display"];
+        $AxisFormat = $Data["Axis"][$AxisID]["Format"];
+        $AxisUnit   = $Data["Axis"][$AxisID]["Unit"];
+        $XStep      = ($this->pChartObject->GraphAreaX2-$this->pChartObject->GraphAreaX1-$XMargin*2)/$XDivs;
+
+        $X = $this->pChartObject->GraphAreaX1 + $XMargin;
+        $Y = $this->pChartObject->GraphAreaY1 + $XMargin;
+
+        $Color = array(
+            "R"=>$Data["Series"][$SerieName]["Color"]["R"],
+            "G"=>$Data["Series"][$SerieName]["Color"]["G"],
+            "B"=>$Data["Series"][$SerieName]["Color"]["B"],
+            "Alpha"=>$Data["Series"][$SerieName]["Color"]["Alpha"]
+        );
+
+        foreach($Points as $Key => $Point) {
+            $Value    = $Data["Series"][$SerieName]["Data"][$Point];
+            $PosArray = $this->pChartObject->scaleComputeY($Value,array("AxisID"=>$AxisID));
+
+            if ( isset($Data["Abscissa"]) && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Point]) ) {
+                $Abscissa = $Data["Series"][$Data["Abscissa"]]["Data"][$Point]." : ";
+            } else {
+                $Abscissa = "";
+            }
+            $Value   = $this->pChartObject->scaleFormat($Value,$AxisMode,$AxisFormat,$AxisUnit);
+            $Weight  = $Data["Series"][$SerieWeightName]["Data"][$Point];
+            $Caption = $Abscissa.$Value." / ".$Weight;
+
+            if ( isset($Data["Series"][$SerieName]["Description"]) ) {
+                $Description = $Data["Series"][$SerieName]["Description"];
+            } else {
+                $Description = "No description";
+            }
+            $Series = "";
+            $Series[] = array("Format" => $Color, "Caption" => $Caption);
+
+            if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT ) {
+                if ( $XDivs == 0 ) { 
+                    $XStep = 0;                 
+                } else { 
+                    $XStep = ($this->pChartObject->GraphAreaX2-$this->pChartObject->GraphAreaX1-$XMargin*2)/$XDivs;                 
+                }
+
+                $X = floor($X + $Point * $XStep);
+                $Y = floor($PosArray);
+            } else {
+                if ( $XDivs == 0 ) { 
+                    $YStep = 0;                 
+                } else {
+                    $YStep = ($this->pChartObject->GraphAreaY2-$this->pChartObject->GraphAreaY1-$XMargin*2)/$XDivs;
+                }
+
+                $X = floor($PosArray);
+                $Y = floor($Y + $Point * $YStep);
+            }
+
+            if ( $DrawPoint == LABEL_POINT_CIRCLE ) {
+                $this->pChartObject->drawFilledCircle(
+                    $X,
+                    $Y,
+                    3,
+                    array(
+                        "R"=>255,
+                        "G"=>255,
+                        "B"=>255,
+                        "BorderR"=>0,
+                        "BorderG"=>0,
+                        "BorderB"=>0
+                    )
+                );
+            } elseif ( $DrawPoint == LABEL_POINT_BOX ) {
+                $this->pChartObject->drawFilledRectangle(
+                    $X-2,
+                    $Y-2,
+                    $X+2,
+                    $Y+2,
+                    array(
+                        "R"=>255,
+                        "G"=>255,
+                        "B"=>255,
+                        "BorderR"=>0,
+                        "BorderG"=>0,
+                        "BorderB"=>0
+                    )
+                );
+            }
+
+            $this->pChartObject->drawLabelBox($X,$Y-3,$Description,$Series,$Format);
+        }
+    }
+}

vendor/szymach/c-pchart/src/Classes/pCache.php

@@ -0,0 +1,367 @@
+<?php
+namespace CpChart\Classes;
+
+/*
+pCache - speed up the rendering by caching up the pictures
+
+Version     : 2.1.4
+Made by     : Jean-Damien POGOLOTTI
+Last Update : 19/01/2014
+
+This file can be distributed under the license you can find at :
+
+               http://www.pchart.net/license
+
+You can find the whole class documentation on the pChart web site.
+*/
+class pCache
+{
+    public $CacheFolder;
+    public $CacheIndex;
+    public $CacheDB;
+
+    /**
+     * Constructor
+     * @param string $Settings
+     */
+    public function __construct($Settings = array())
+    {
+        $CacheFolder	= isset($Settings["CacheFolder"]) ? $Settings["CacheFolder"] : __DIR__."/../../app/cache";
+        $CacheIndex	= isset($Settings["CacheIndex"]) ? $Settings["CacheIndex"] : "index.db";
+        $CacheDB	= isset($Settings["CacheDB"]) ? $Settings["CacheDB"] : "cache.db";
+
+        $this->CacheFolder = $CacheFolder;
+        $this->CacheIndex  = $CacheIndex;
+        $this->CacheDB     = $CacheDB;
+        if (!file_exists($this->CacheFolder."/".$this->CacheIndex)) { 
+            touch($this->CacheFolder."/".$this->CacheIndex);             
+        }
+        if (!file_exists($this->CacheFolder."/".$this->CacheDB)) { 
+            touch($this->CacheFolder."/".$this->CacheDB);             
+        }
+    }
+
+    /**
+     * Flush the cache contents
+     */
+    public function flush()
+    {
+        if (file_exists($this->CacheFolder."/".$this->CacheIndex)) { 
+            unlink($this->CacheFolder."/".$this->CacheIndex); 
+            touch($this->CacheFolder."/".$this->CacheIndex);             
+        }
+        if (file_exists($this->CacheFolder."/".$this->CacheDB)) { 
+            unlink($this->CacheFolder."/".$this->CacheDB);
+            touch($this->CacheFolder."/".$this->CacheDB);             
+        }
+    }
+
+    /**
+     * Return the MD5 of the data array to clearly identify the chart
+     * @param type $Data
+     * @param type $Marker
+     * @return type
+     */
+    public function getHash($Data,$Marker="")
+    { 
+        return(md5($Marker.serialize($Data->Data)));         
+    }
+
+    /**
+     * Write the generated picture to the cache
+     * @param type $ID
+     * @param type $pChartObject
+     */
+    public function writeToCache($ID,$pChartObject)
+    {
+        /* Compute the paths */
+        $TemporaryFile = $this->CacheFolder."/tmp_".rand(0,1000).".png";
+        $Database      = $this->CacheFolder."/".$this->CacheDB;
+        $Index         = $this->CacheFolder."/".$this->CacheIndex;
+        /* Flush the picture to a temporary file */
+        imagepng($pChartObject->Picture ,$TemporaryFile);
+
+        /* Retrieve the files size */
+        $PictureSize = filesize($TemporaryFile);
+        $DBSize      = filesize($Database);
+
+        /* Save the index */
+        $Handle = fopen($Index,"a");
+        fwrite($Handle, $ID.",".$DBSize.",".$PictureSize.",".time().",0\r\n");
+        fclose($Handle);
+
+        /* Get the picture raw contents */
+        $Handle = fopen($TemporaryFile,"r");
+        $Raw    = fread($Handle,$PictureSize);
+        fclose($Handle);
+
+        /* Save the picture in the solid database file */
+        $Handle = fopen($Database,"a");
+        fwrite($Handle, $Raw);
+        fclose($Handle);
+
+        /* Remove temporary file */
+        unlink($TemporaryFile);
+    }
+
+    /**
+     * Remove object older than the specified TS
+     * @param type $Expiry
+     */
+    public function removeOlderThan($Expiry)
+    { 
+        $this->dbRemoval(array("Expiry"=>$Expiry));         
+    }
+
+    /**
+     * Remove an object from the cache
+     * @param type $ID
+     */
+    public function remove($ID)
+    { 
+        $this->dbRemoval(array("Name"=>$ID));
+    }
+
+    /**
+     * Remove with specified criterias
+     * @param type $Settings
+     * @return type
+     */
+    public function dbRemoval($Settings)
+    {
+        $ID     = isset($Settings["Name"]) ? $Settings["Name"] : null;
+        $Expiry = isset($Settings["Expiry"]) ? $Settings["Expiry"] : -(24*60*60);
+        $TS     = time()-$Expiry;
+
+        /* Compute the paths */
+        $Database     = $this->CacheFolder."/".$this->CacheDB;
+        $Index        = $this->CacheFolder."/".$this->CacheIndex;
+        $DatabaseTemp = $this->CacheFolder."/".$this->CacheDB.".tmp";
+        $IndexTemp    = $this->CacheFolder."/".$this->CacheIndex.".tmp";
+
+        /* Single file removal */
+        if ( $ID != null ) {
+            /* Retrieve object informations */
+            $Object = $this->isInCache($ID,true);
+
+            /* If it's not in the cache DB, go away */
+            if ( !$Object ) { 
+                return(0);                 
+            }
+        }
+
+        /* Create the temporary files */
+        if (!file_exists($DatabaseTemp)) { 
+            touch($DatabaseTemp);             
+        }
+        if (!file_exists($IndexTemp)) { 
+            touch($IndexTemp);            
+        }
+
+        /* Open the file handles */
+        $IndexHandle     = @fopen($Index, "r");
+        $IndexTempHandle = @fopen($IndexTemp, "w");
+        $DBHandle        = @fopen($Database, "r");
+        $DBTempHandle    = @fopen($DatabaseTemp, "w");
+
+        /* Remove the selected ID from the database */
+        while (!feof($IndexHandle)) {
+            $Entry    = fgets($IndexHandle, 4096);
+            $Entry    = str_replace("\r","",$Entry);
+            $Entry    = str_replace("\n","",$Entry);
+            $Settings = preg_split("/,/",$Entry);
+
+            if ( $Entry != "" ) {
+                $PicID       = $Settings[0];
+                $DBPos       = $Settings[1];
+                $PicSize     = $Settings[2];
+                $GeneratedTS = $Settings[3];
+                $Hits        = $Settings[4];
+
+                if ( $Settings[0] != $ID && $GeneratedTS > $TS) {
+                    $CurrentPos  = ftell($DBTempHandle);
+                    fwrite(
+                        $IndexTempHandle, 
+                        $PicID.",".$CurrentPos.",".$PicSize.","
+                        .$GeneratedTS.",".$Hits."\r\n"
+                    );
+
+                  fseek($DBHandle,$DBPos);
+                  $Picture = fread($DBHandle,$PicSize);
+                  fwrite($DBTempHandle,$Picture);
+                }
+            }
+        }
+
+        /* Close the handles */
+        fclose($IndexHandle);
+        fclose($IndexTempHandle);
+        fclose($DBHandle);
+        fclose($DBTempHandle);
+
+        /* Remove the prod files */
+        unlink($Database);
+        unlink($Index);
+
+        /* Swap the temp & prod DB */
+        rename($DatabaseTemp,$Database);
+        rename($IndexTemp,$Index);
+    }
+    
+    /**
+     * Is the file in cache?
+     * @param type $ID
+     * @param type $Verbose
+     * @param type $UpdateHitsCount
+     * @return boolean
+     */
+    public function isInCache($ID,$Verbose=false,$UpdateHitsCount=false)
+    {
+        /* Compute the paths */
+        $Index = $this->CacheFolder."/".$this->CacheIndex;
+
+        /* Search the picture in the index file */
+        $Handle = @fopen($Index, "r");
+        while (!feof($Handle)) {
+            $IndexPos = ftell($Handle);
+            $Entry = fgets($Handle, 4096);
+            if ( $Entry != "" ) {
+                $Settings = preg_split("/,/",$Entry);
+                $PicID    = $Settings[0];
+                if ( $PicID == $ID ) {
+                    fclose($Handle);
+
+                    $DBPos       = $Settings[1];
+                    $PicSize     = $Settings[2];
+                    $GeneratedTS = $Settings[3];
+                    $Hits        = intval($Settings[4]);
+
+                    if ( $UpdateHitsCount ) {
+                        $Hits++;
+                        if ( strlen($Hits) < 7 ) { 
+                            $Hits = $Hits.str_repeat(" ",7-strlen($Hits));                             
+                        }
+
+                        $Handle = @fopen($Index, "r+");
+                        fseek($Handle,$IndexPos);
+                        fwrite(
+                            $Handle, 
+                            $PicID.",".$DBPos.",".$PicSize.","
+                            .$GeneratedTS.",".$Hits."\r\n"
+                        );
+                        fclose($Handle);
+                    }
+
+                    if ($Verbose) { 
+                        return(
+                            array(
+                                "DBPos" => $DBPos,
+                                "PicSize" => $PicSize,
+                                "GeneratedTS" => $GeneratedTS,
+                                "Hits" => $Hits
+                            )
+                        );                         
+                    } else { 
+                        return true;                         
+                    }
+                }
+            }
+        }
+        fclose($Handle);
+
+        /* Picture isn't in the cache */
+        return false;
+    }
+
+    /**
+     * Automatic output method based on the calling interface
+     * @param type $ID
+     * @param type $Destination
+     */
+    public function autoOutput($ID,$Destination="output.png")
+    {
+        if (php_sapi_name() == "cli") {
+            $this->saveFromCache($ID,$Destination);
+        } else {
+            $this->strokeFromCache($ID);
+        }
+    }
+    
+    /**
+     * Show image from cache
+     * @param type $ID
+     * @return boolean
+     */
+    public function strokeFromCache($ID)
+    {
+        /* Get the raw picture from the cache */
+        $Picture = $this->getFromCache($ID);
+
+        /* Do we have a hit? */
+        if ( $Picture == null ) { 
+            return false;
+        }
+
+        header('Content-type: image/png');
+        echo $Picture;
+
+        return true;
+    }
+    
+    /**
+     * Save file from cache.
+     * @param type $ID
+     * @param type $Destination
+     * @return boolean
+     */
+    public function saveFromCache($ID,$Destination)
+    {
+        /* Get the raw picture from the cache */
+        $Picture = $this->getFromCache($ID);
+
+        /* Do we have a hit? */
+        if ( $Picture == null ) { 
+            return false;
+        }
+        
+        /* Flush the picture to a file */
+        $Handle = fopen($Destination,"w");
+        fwrite($Handle,$Picture);
+        fclose($Handle);
+
+        /* All went fine */
+        return true;
+    }
+    
+    /**
+     * Get file from cache
+     * @param type $ID
+     * @return string
+     */
+    public function getFromCache($ID)
+    {
+        /* Compute the path */
+        $Database = $this->CacheFolder."/".$this->CacheDB;
+
+        /* Lookup for the picture in the cache */
+        $CacheInfo = $this->isInCache($ID,true,true);
+
+        /* Not in the cache */
+        if (!$CacheInfo) { 
+            return null;
+        }
+
+        /* Get the database extended information */     
+        $DBPos   = $CacheInfo["DBPos"];
+        $PicSize = $CacheInfo["PicSize"];
+
+        /* Extract the picture from the solid cache file */
+        $Handle = @fopen($Database, "r");
+        fseek($Handle,$DBPos);
+        $Picture = fread($Handle,$PicSize);
+        fclose($Handle);
+
+        /* Return back the raw picture data */
+        return $Picture;
+    }
+}

vendor/szymach/c-pchart/src/Classes/pImage.php

@@ -0,0 +1,764 @@
+<?php
+namespace CpChart\Classes;
+/*
+pDraw - pChart core class
+
+Version     : 2.1.4
+Made by     : Jean-Damien POGOLOTTI
+Last Update : 19/01/2014
+
+This file can be distributed under the license you can find at :
+
+               http://www.pchart.net/license
+
+You can find the whole class documentation on the pChart web site.
+*/
+
+/* The GD extension is mandatory */
+if (!extension_loaded('gd') && !extension_loaded('gd2')) {
+    throw new \Exception("GD extension must be loaded. \r\n");
+}
+
+class pImage extends pDraw
+{
+    /* Image settings, size, quality, .. */
+    public $XSize                   = null;     // Width of the picture
+    public $YSize                   = null;     // Height of the picture
+    public $Picture                 = null;     // GD picture object
+    public $Antialias               = true;     // Turn antialias on or off
+    public $AntialiasQuality        = 0;        // Quality of the antialiasing implementation (0-1)
+    public $Mask                    = "";       // Already drawn pixels mask (Filled circle implementation)
+    public $TransparentBackground   = false;    // Just to know if we need to flush the alpha channels when rendering
+
+    /* Graph area settings */
+    public $GraphAreaX1	= null; // Graph area X origin
+    public $GraphAreaY1	= null; // Graph area Y origin
+    public $GraphAreaX2	= null; // Graph area bottom right X position
+    public $GraphAreaY2	= null; // Graph area bottom right Y position
+
+    /* Scale settings */
+    public $ScaleMinDivHeight = 20; // Minimum height for scame divs
+
+    /* Font properties */
+    public $FontName	= "GeosansLight.ttf";           // Default font file
+    public $FontSize	= 12;				// Default font size
+    public $FontBox	= null;				// Return the bounding box of the last written string
+    public $FontColorR	= 0;				// Default color settings
+    public $FontColorG	= 0;				// Default color settings
+    public $FontColorB	= 0;				// Default color settings
+    public $FontColorA	= 100;				// Default transparency
+
+    /* Shadow properties */
+    public $Shadow		= false;		// Turn shadows on or off
+    public $ShadowX		= null;			// X Offset of the shadow
+    public $ShadowY		= null;			// Y Offset of the shadow
+    public $ShadowR		= null;			// R component of the shadow
+    public $ShadowG		= null;			// G component of the shadow
+    public $ShadowB		= null;			// B component of the shadow
+    public $Shadowa		= null;			// Alpha level of the shadow
+
+    /* Image map */
+    public $ImageMap            = null;			// Aray containing the image map
+    public $ImageMapIndex	= "pChart";		// Name of the session array
+    public $ImageMapStorageMode = null;			// Save the current imagemap storage mode
+    public $ImageMapAutoDelete  = true;			// Automatic deletion of the image map temp files
+
+    /* Data Set */
+    public $DataSet		= null;                 // Attached dataset
+
+    /* Last generated chart info */
+    public $LastChartLayout	= CHART_LAST_LAYOUT_REGULAR;	// Last layout : regular or stacked
+
+    /**
+     * Class constructor
+     * @param type $XSize
+     * @param type $YSize
+     * @param type $DataSet
+     * @param type $TransparentBackground
+     */
+    public function __construct(
+        $XSize,
+        $YSize,
+        $DataSet = null,
+        $TransparentBackground = false
+    ) {
+        // set proper path for resources and the default font name
+        $this->FontName = $this->loadFont($this->FontName, 'fonts');
+        
+        $this->TransparentBackground = $TransparentBackground;
+
+        if ( $DataSet != null ) { 
+            $this->DataSet = $DataSet;             
+        }
+
+        $this->XSize   = $XSize;
+        $this->YSize   = $YSize;
+        $this->Picture = imagecreatetruecolor($XSize,$YSize);
+
+        if ( $this->TransparentBackground ) {
+            imagealphablending($this->Picture,false);
+            imagefilledrectangle(
+                $this->Picture, 
+                0,
+                0,
+                $XSize, 
+                $YSize, 
+                imagecolorallocatealpha($this->Picture, 255, 255, 255, 127)
+            );
+            imagealphablending($this->Picture,true);
+            imagesavealpha($this->Picture,true); 
+        } else {
+            $C_White = $this->AllocateColor($this->Picture,255,255,255);
+            imagefilledrectangle($this->Picture,0,0,$XSize,$YSize,$C_White);
+        }
+    }
+
+    /**
+     * Enable / Disable and set shadow properties
+     * @param type $Enabled
+     * @param type $Format
+     */
+    public function setShadow($Enabled=true,$Format="")
+    {
+        $X	    = isset($Format["X"]) ? $Format["X"] : 2;
+        $Y	    = isset($Format["Y"]) ? $Format["Y"] : 2;
+        $R	    = isset($Format["R"]) ? $Format["R"] : 0;
+        $G	    = isset($Format["G"]) ? $Format["G"] : 0;
+        $B	    = isset($Format["B"]) ? $Format["B"] : 0;
+        $Alpha      = isset($Format["Alpha"]) ? $Format["Alpha"] : 10;
+
+        $this->Shadow  = $Enabled;
+        $this->ShadowX = $X;
+        $this->ShadowY = $Y;
+        $this->ShadowR = $R;
+        $this->ShadowG = $G;
+        $this->ShadowB = $B;
+        $this->Shadowa = $Alpha;
+    }
+
+    /**
+     * Set the graph area position
+     * @param type $X1
+     * @param type $Y1
+     * @param type $X2
+     * @param type $Y2
+     * @return type
+     */
+    public function setGraphArea($X1,$Y1,$X2,$Y2)
+    {
+        if ( $X2 < $X1 || $X1 == $X2 || $Y2 < $Y1 || $Y1 == $Y2 ) { 
+            return(-1);             
+        }
+
+        $this->GraphAreaX1 = $X1; $this->DataSet->Data["GraphArea"]["X1"] = $X1;
+        $this->GraphAreaY1 = $Y1; $this->DataSet->Data["GraphArea"]["Y1"] = $Y1;
+        $this->GraphAreaX2 = $X2; $this->DataSet->Data["GraphArea"]["X2"] = $X2;
+        $this->GraphAreaY2 = $Y2; $this->DataSet->Data["GraphArea"]["Y2"] = $Y2;
+    }
+
+    /**
+     * Return the width of the picture
+     * @return type
+     */
+    public function getWidth()
+    { 
+        return($this->XSize);
+    }
+
+    /**
+     * Return the heigth of the picture
+     * @return type
+     */
+    public function getHeight()
+    { 
+        return($this->YSize);         
+    }
+
+    /**
+     * Render the picture to a file
+     * @param type $FileName
+     */
+    public function render($FileName)
+    {
+        if ( $this->TransparentBackground ) { 
+            imagealphablending($this->Picture,false); 
+            imagesavealpha($this->Picture,true);             
+        }
+        imagepng($this->Picture,$FileName);
+    }
+
+    /**
+     * Render the picture to a web browser stream
+     * @param type $BrowserExpire
+     */
+    public function stroke($BrowserExpire=false)
+    {
+        if ( $this->TransparentBackground ) { 
+            imagealphablending($this->Picture,false); 
+            imagesavealpha($this->Picture,true);             
+        }
+
+        if ( $BrowserExpire ) {
+            header("Expires: Mon, 26 Jul 1997 05:00:00 GMT");
+            header("Cache-Control: no-cache");
+            header("Pragma: no-cache");
+        }
+
+        header('Content-type: image/png');
+        imagepng($this->Picture);
+    }
+
+    /**
+     * Automatic output method based on the calling interface
+     * @param type $FileName
+     */
+    public function autoOutput($FileName="output.png")
+    {
+        if (php_sapi_name() == "cli") {
+            $this->Render($FileName);
+        } else {
+            $this->Stroke();
+        }
+    }
+
+    /**
+     * Return the length between two points
+     * @param type $X1
+     * @param type $Y1
+     * @param type $X2
+     * @param type $Y2
+     * @return type
+     */
+    public function getLength($X1,$Y1,$X2,$Y2)
+    { 
+        return(sqrt(pow(max($X1,$X2)-min($X1,$X2),2)+pow(max($Y1,$Y2)-min($Y1,$Y2),2)));         
+    }
+
+    /**
+     * Return the orientation of a line
+     * @param type $X1
+     * @param type $Y1
+     * @param type $X2
+     * @param type $Y2
+     * @return type
+     */
+    public function getAngle($X1,$Y1,$X2,$Y2)
+    {
+        $Opposite = $Y2 - $Y1; $Adjacent = $X2 - $X1;
+        $Angle = rad2deg(atan2($Opposite,$Adjacent));
+        if ($Angle > 0) { 
+            return($Angle);
+        } else { 
+            return(360-abs($Angle));                 
+        }
+    }
+
+    /**
+     * Return the surrounding box of text area
+     * @param type $X
+     * @param type $Y
+     * @param type $FontName
+     * @param type $FontSize
+     * @param type $Angle
+     * @param type $Text
+     * @return type
+     */
+    public function getTextBox_deprecated($X,$Y,$FontName,$FontSize,$Angle,$Text)
+    {
+        $FontName  = $this->loadFont($FontName, 'fonts');
+        $Size    = imagettfbbox($FontSize,$Angle,$FontName,$Text);
+        $Width   = $this->getLength($Size[0],$Size[1],$Size[2],$Size[3])+1;
+        $Height  = $this->getLength($Size[2],$Size[3],$Size[4],$Size[5])+1;
+
+        $RealPos[0]["X"] = $X; 
+        $RealPos[0]["Y"] = $Y;
+        $RealPos[1]["X"] = cos((360-$Angle)*PI/180)*$Width + $RealPos[0]["X"]; 
+        $RealPos[1]["Y"] = sin((360-$Angle)*PI/180)*$Width + $RealPos[0]["Y"];
+        $RealPos[2]["X"] = cos((270-$Angle)*PI/180)*$Height + $RealPos[1]["X"]; 
+        $RealPos[2]["Y"] = sin((270-$Angle)*PI/180)*$Height + $RealPos[1]["Y"];
+        $RealPos[3]["X"] = cos((180-$Angle)*PI/180)*$Width + $RealPos[2]["X"]; 
+        $RealPos[3]["Y"] = sin((180-$Angle)*PI/180)*$Width + $RealPos[2]["Y"];
+
+        $RealPos[TEXT_ALIGN_BOTTOMLEFT]["X"] = $RealPos[0]["X"];	
+        $RealPos[TEXT_ALIGN_BOTTOMLEFT]["Y"] = $RealPos[0]["Y"];
+        $RealPos[TEXT_ALIGN_BOTTOMRIGHT]["X"] = $RealPos[1]["X"];	
+        $RealPos[TEXT_ALIGN_BOTTOMRIGHT]["Y"] = $RealPos[1]["Y"];
+
+        return($RealPos);
+    }
+
+    /**
+     * Return the surrounding box of text area
+     * @param type $X
+     * @param type $Y
+     * @param type $FontName
+     * @param type $FontSize
+     * @param type $Angle
+     * @param type $Text
+     * @return type
+     */
+    public function getTextBox($X,$Y,$FontName,$FontSize,$Angle,$Text)
+    {
+        $FontName  = $this->loadFont($FontName, 'fonts');
+        $coords = imagettfbbox($FontSize, 0, $FontName, $Text);
+
+        $a = deg2rad($Angle); 
+        $ca = cos($a); 
+        $sa = sin($a); 
+        $RealPos = array();
+        for ($i = 0; $i < 7; $i += 2) {
+            $RealPos[$i/2]["X"] = $X + round($coords[$i] * $ca + $coords[$i+1] * $sa);
+            $RealPos[$i/2]["Y"] = $Y + round($coords[$i+1] * $ca - $coords[$i] * $sa);
+        }
+
+        $RealPos[TEXT_ALIGN_BOTTOMLEFT]["X"]	= $RealPos[0]["X"];	
+        $RealPos[TEXT_ALIGN_BOTTOMLEFT]["Y"]	= $RealPos[0]["Y"];
+        $RealPos[TEXT_ALIGN_BOTTOMRIGHT]["X"]	= $RealPos[1]["X"];	
+        $RealPos[TEXT_ALIGN_BOTTOMRIGHT]["Y"]	= $RealPos[1]["Y"];
+        $RealPos[TEXT_ALIGN_TOPLEFT]["X"]	= $RealPos[3]["X"];	
+        $RealPos[TEXT_ALIGN_TOPLEFT]["Y"]	= $RealPos[3]["Y"];
+        $RealPos[TEXT_ALIGN_TOPRIGHT]["X"]	= $RealPos[2]["X"];	
+        $RealPos[TEXT_ALIGN_TOPRIGHT]["Y"]	= $RealPos[2]["Y"];
+        $RealPos[TEXT_ALIGN_BOTTOMMIDDLE]["X"]	= ($RealPos[1]["X"]-$RealPos[0]["X"])/2+$RealPos[0]["X"];	
+        $RealPos[TEXT_ALIGN_BOTTOMMIDDLE]["Y"]	= ($RealPos[0]["Y"]-$RealPos[1]["Y"])/2+$RealPos[1]["Y"];
+        $RealPos[TEXT_ALIGN_TOPMIDDLE]["X"]	= ($RealPos[2]["X"]-$RealPos[3]["X"])/2+$RealPos[3]["X"];	
+        $RealPos[TEXT_ALIGN_TOPMIDDLE]["Y"]	= ($RealPos[3]["Y"]-$RealPos[2]["Y"])/2+$RealPos[2]["Y"];
+        $RealPos[TEXT_ALIGN_MIDDLELEFT]["X"]	= ($RealPos[0]["X"]-$RealPos[3]["X"])/2+$RealPos[3]["X"];	
+        $RealPos[TEXT_ALIGN_MIDDLELEFT]["Y"]	= ($RealPos[0]["Y"]-$RealPos[3]["Y"])/2+$RealPos[3]["Y"];
+        $RealPos[TEXT_ALIGN_MIDDLERIGHT]["X"]	= ($RealPos[1]["X"]-$RealPos[2]["X"])/2+$RealPos[2]["X"];	
+        $RealPos[TEXT_ALIGN_MIDDLERIGHT]["Y"]	= ($RealPos[1]["Y"]-$RealPos[2]["Y"])/2+$RealPos[2]["Y"];
+        $RealPos[TEXT_ALIGN_MIDDLEMIDDLE]["X"]	= ($RealPos[1]["X"]-$RealPos[3]["X"])/2+$RealPos[3]["X"];	
+        $RealPos[TEXT_ALIGN_MIDDLEMIDDLE]["Y"]	= ($RealPos[0]["Y"]-$RealPos[2]["Y"])/2+$RealPos[2]["Y"];
+
+        return($RealPos);
+    }
+
+    /**
+     * Set current font properties
+     * @param type $Format
+     */
+    public function setFontProperties($Format="")
+    {
+        $R          = isset($Format["R"]) ? $Format["R"] : -1;
+        $G          = isset($Format["G"]) ? $Format["G"] : -1;
+        $B          = isset($Format["B"]) ? $Format["B"] : -1;
+        $Alpha      = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
+        $FontName   = isset($Format["FontName"]) ? $Format["FontName"] : null;
+        $FontSize   = isset($Format["FontSize"]) ? $Format["FontSize"] : null;
+
+        if ( $R != -1)       { 
+            $this->FontColorR = $R;
+        }
+        if ( $G != -1)       {  
+            $this->FontColorG = $G;             
+        }
+        if ( $B != -1)       {  
+            $this->FontColorB = $B;
+        }
+        if ( $Alpha != null) {  
+            $this->FontColorA = $Alpha;             
+        }
+
+        if ($FontName != null) {
+            $this->FontName = $this->loadFont($FontName, 'fonts');
+        }
+        if ($FontSize != null) {
+            $this->FontSize = $FontSize;
+        }
+    }
+
+    /**
+     * Returns the 1st decimal values (used to correct AA bugs)
+     * @param type $Value
+     * @return type
+     */
+    public function getFirstDecimal($Value)
+    {
+        $Values = preg_split("/\./",$Value);
+        if ( isset($Values[1]) ) { 
+            return(substr($Values[1],0,1));             
+        } else { 
+            return(0);             
+        }
+    }
+
+    /**
+     * Attach a dataset to your pChart Object
+     * @param type $DataSet
+     */
+    public function setDataSet(&$DataSet)
+    { $this->DataSet = $DataSet; }
+
+    /**
+     * Print attached dataset contents to STDOUT
+     */
+    public function printDataSet()
+    { print_r($this->DataSet); }
+
+    /**
+     * Initialise the image map methods
+     * @param type $Name
+     * @param type $StorageMode
+     * @param type $UniqueID
+     * @param type $StorageFolder
+     */
+    public function initialiseImageMap(
+        $Name="pChart",
+        $StorageMode=IMAGE_MAP_STORAGE_SESSION,
+        $UniqueID="imageMap",
+        $StorageFolder="tmp"
+    ) {
+        $this->ImageMapIndex       = $Name;
+        $this->ImageMapStorageMode = $StorageMode;
+
+        if ($StorageMode == IMAGE_MAP_STORAGE_SESSION) {
+            if(!isset($_SESSION)) { 
+                session_start();                 
+            }
+            $_SESSION[$this->ImageMapIndex] = null;
+        } elseif($StorageMode == IMAGE_MAP_STORAGE_FILE) {
+            $this->ImageMapFileName 		= $UniqueID;
+            $this->ImageMapStorageFolder	= $StorageFolder;
+
+            if (file_exists($StorageFolder."/".$UniqueID.".map")) { 
+                unlink($StorageFolder."/".$UniqueID.".map");                 
+            }
+        }
+    }
+
+    /**
+     * Add a zone to the image map 
+     * @param type $Type
+     * @param type $Plots
+     * @param type $Color
+     * @param type $Title
+     * @param type $Message
+     * @param type $HTMLEncode
+     */
+    public function addToImageMap(
+        $Type,
+        $Plots,
+        $Color=null,
+        $Title=null,
+        $Message=null,
+        $HTMLEncode=false
+    ) {
+        if ( $this->ImageMapStorageMode == null ) { 
+            $this->initialiseImageMap();             
+        }
+
+        /* Encode the characters in the imagemap in HTML standards */
+        $Title   = str_replace("&#8364;","\u20AC",$Title);
+        $Title   = htmlentities($Title,ENT_QUOTES,"ISO-8859-15");
+        if ( $HTMLEncode ) {
+            $Message = htmlentities($Message,ENT_QUOTES,"ISO-8859-15");
+            $Message = str_replace("&lt;","<",$Message);
+            $Message = str_replace("&gt;",">",$Message);
+        }
+
+        if ( $this->ImageMapStorageMode == IMAGE_MAP_STORAGE_SESSION ) {
+            if (!isset($_SESSION)) { 
+                $this->initialiseImageMap();                 
+            }
+            $_SESSION[$this->ImageMapIndex][] = array($Type,$Plots,$Color,$Title,$Message);
+        } elseif($this->ImageMapStorageMode == IMAGE_MAP_STORAGE_FILE) {
+            $Handle = fopen(
+                $this->ImageMapStorageFolder."/".$this->ImageMapFileName.".map", 
+                'a'
+            );
+            fwrite(
+                $Handle, 
+                $Type.IMAGE_MAP_DELIMITER.$Plots.IMAGE_MAP_DELIMITER.$Color
+                .IMAGE_MAP_DELIMITER.$Title.IMAGE_MAP_DELIMITER.$Message."\r\n"
+            );
+            fclose($Handle);
+        }
+    }
+
+    /**
+     * Remove VOID values from an imagemap custom values array
+     * @param type $SerieName
+     * @param type $Values
+     * @return type
+     */
+    public function removeVOIDFromArray($SerieName, $Values)
+    {
+        if ( !isset($this->DataSet->Data["Series"][$SerieName]) ) { 
+            return(-1);             
+        }
+
+        $Result = "";
+        foreach ($this->DataSet->Data["Series"][$SerieName]["Data"] as $Key => $Value) { 
+            if ( $Value != VOID && isset($Values[$Key]) ) { 
+                $Result[] = $Values[$Key];                 
+            }
+        }
+        return($Result);
+    }
+
+    /**
+     * Replace the title of one image map serie
+     * @param type $OldTitle
+     * @param type $NewTitle
+     * @return type
+     */
+    public function replaceImageMapTitle($OldTitle, $NewTitle)
+    {
+        if ( $this->ImageMapStorageMode == null ) { 
+            return(-1);             
+        }
+
+        if ( is_array($NewTitle) ) { 
+            $NewTitle = $this->removeVOIDFromArray($OldTitle, $NewTitle);             
+        }
+
+        if ( $this->ImageMapStorageMode == IMAGE_MAP_STORAGE_SESSION ) {
+            if (!isset($_SESSION)) { 
+                return(-1);                 
+            }
+            if ( is_array($NewTitle) ) { 
+                $ID = 0; 
+                foreach($_SESSION[$this->ImageMapIndex] as $Key => $Settings) { 
+                    if ( $Settings[3] == $OldTitle && isset($NewTitle[$ID])) { 
+                        $_SESSION[$this->ImageMapIndex][$Key][3] = $NewTitle[$ID]; 
+                        $ID++;                         
+                    }                     
+                }                     
+            } else { 
+                foreach($_SESSION[$this->ImageMapIndex] as $Key => $Settings) { 
+                    if ( $Settings[3] == $OldTitle ) { 
+                        $_SESSION[$this->ImageMapIndex][$Key][3] = $NewTitle;                     
+                    }                     
+                }
+            }
+        } elseif( $this->ImageMapStorageMode == IMAGE_MAP_STORAGE_FILE ) {
+            $TempArray = "";
+            $Handle    = @fopen($this->ImageMapStorageFolder."/".$this->ImageMapFileName.".map", "r");
+            if ($Handle) {
+            while (($Buffer = fgets($Handle, 4096)) !== false) {
+                $Fields = preg_split(
+                    "/".IMAGE_MAP_DELIMITER."/",
+                    str_replace(array(chr(10),chr(13)),"",$Buffer)
+                );
+                $TempArray[] = array($Fields[0],$Fields[1],$Fields[2],$Fields[3],$Fields[4]);
+            }
+            fclose($Handle);
+
+            if ( is_array($NewTitle) ) { 
+                 $ID = 0; 
+                 foreach($TempArray as $Key => $Settings) { 
+                     if ( $Settings[3] == $OldTitle && isset($NewTitle[$ID]) ) { 
+                         $TempArray[$Key][3] = $NewTitle[$ID]; $ID++;                         
+                     }                      
+                 }                      
+            } else { 
+                foreach($TempArray as $Key => $Settings) { 
+                    if ( $Settings[3] == $OldTitle ) { 
+                        $TempArray[$Key][3] = $NewTitle;                         
+                    }                     
+                }                     
+            }
+
+             $Handle = fopen(
+                 $this->ImageMapStorageFolder."/".$this->ImageMapFileName.".map", 
+                 'w'
+             );
+             foreach($TempArray as $Key => $Settings) { 
+                fwrite(
+                    $Handle, 
+                    $Settings[0].IMAGE_MAP_DELIMITER.$Settings[1]
+                        .IMAGE_MAP_DELIMITER.$Settings[2]
+                        .IMAGE_MAP_DELIMITER.$Settings[3]
+                        .IMAGE_MAP_DELIMITER.$Settings[4]."\r\n"
+                );                  
+             }
+             fclose($Handle);
+            }
+        }
+    }
+
+    /**
+     * Replace the values of the image map contents
+     * @param type $Title
+     * @param type $Values
+     * @return type
+     */
+    public function replaceImageMapValues($Title, $Values)
+    {
+        if ( $this->ImageMapStorageMode == null ) { return(-1); }
+
+        $Values = $this->removeVOIDFromArray($Title, $Values);
+        $ID = 0; 
+        if ( $this->ImageMapStorageMode == IMAGE_MAP_STORAGE_SESSION ) {
+            if(!isset($_SESSION)) { return(-1); }
+            foreach($_SESSION[$this->ImageMapIndex] as $Key => $Settings) { 
+                if ( $Settings[3] == $Title ) { 
+                    if ( isset($Values[$ID]) ) { 
+                        $_SESSION[$this->ImageMapIndex][$Key][4] = $Values[$ID];                         
+                    } 
+                    $ID++;                     
+                }
+            }
+        } elseif( $this->ImageMapStorageMode == IMAGE_MAP_STORAGE_FILE ) {
+            $TempArray = "";
+            $Handle    = @fopen(
+                $this->ImageMapStorageFolder."/".$this->ImageMapFileName.".map",
+                "r"
+            );
+            if ($Handle) {
+                while (($Buffer = fgets($Handle, 4096)) !== false) {
+                    $Fields = preg_split(
+                            "/".IMAGE_MAP_DELIMITER."/",
+                            str_replace(array(chr(10),chr(13)),"",$Buffer)
+                    );
+                    $TempArray[] = array($Fields[0],$Fields[1],$Fields[2],$Fields[3],$Fields[4]);
+                }
+                fclose($Handle);
+
+                foreach($TempArray as $Key => $Settings) { 
+                    if ( $Settings[3] == $Title ) { 
+                        if ( isset($Values[$ID]) ) { 
+                            $TempArray[$Key][4] = $Values[$ID];                             
+                        } 
+                        $ID++;                         
+                    }                         
+                }
+
+                $Handle = fopen(
+                    $this->ImageMapStorageFolder."/".$this->ImageMapFileName.".map",
+                    'w'
+                );
+                foreach($TempArray as $Key => $Settings) { 
+                    fwrite(
+                        $Handle, 
+                        $Settings[0].IMAGE_MAP_DELIMITER.$Settings[1]
+                            .IMAGE_MAP_DELIMITER.$Settings[2]
+                            .IMAGE_MAP_DELIMITER.$Settings[3]
+                            .IMAGE_MAP_DELIMITER.$Settings[4]."\r\n"
+                    );                 
+                }
+                fclose($Handle);
+            }
+        }
+    }
+
+    /**
+     * Dump the image map
+     * @param type $Name
+     * @param type $StorageMode
+     * @param type $UniqueID
+     * @param type $StorageFolder
+     */
+    public function dumpImageMap(
+        $Name="pChart",
+        $StorageMode=IMAGE_MAP_STORAGE_SESSION,
+        $UniqueID="imageMap",
+        $StorageFolder="tmp"
+    ) {
+        $this->ImageMapIndex 		= $Name;
+        $this->ImageMapStorageMode	= $StorageMode;
+
+        if ( $this->ImageMapStorageMode == IMAGE_MAP_STORAGE_SESSION ) {
+            if(!isset($_SESSION)) { 
+                session_start();                 
+            }
+            if ( $_SESSION[$Name] != null ) {
+                foreach($_SESSION[$Name] as $Key => $Params) { 
+                    echo $Params[0].IMAGE_MAP_DELIMITER.$Params[1]
+                         .IMAGE_MAP_DELIMITER.$Params[2].IMAGE_MAP_DELIMITER
+                         .$Params[3].IMAGE_MAP_DELIMITER.$Params[4]."\r\n";
+                }
+            }
+        } elseif( $this->ImageMapStorageMode == IMAGE_MAP_STORAGE_FILE ) {
+            if (file_exists($StorageFolder."/".$UniqueID.".map")) {
+                $Handle = @fopen($StorageFolder."/".$UniqueID.".map", "r");
+                if ($Handle) { 
+                    while (($Buffer = fgets($Handle, 4096)) !== false) { 
+                        echo $Buffer;                         
+                    }
+                }
+                fclose($Handle);
+
+                if ( $this->ImageMapAutoDelete ) { 
+                    unlink($StorageFolder."/".$UniqueID.".map");                     
+                }
+            }
+        }
+
+        /* When the image map is returned to the client, the script ends */
+        exit();
+    }
+
+    /**
+     * Return the HTML converted color from the RGB composite values
+     * @param type $R
+     * @param type $G
+     * @param type $B
+     * @return type
+     */
+    public function toHTMLColor($R,$G,$B)
+    {
+        $R=intval($R); 
+        $G=intval($G); 
+        $B=intval($B);
+        $R=dechex($R<0?0:($R>255?255:$R)); 
+        $G=dechex($G<0?0:($G>255?255:$G));
+        $B=dechex($B<0?0:($B>255?255:$B));
+        $Color="#".(strlen($R) < 2?'0':'').$R; 
+        $Color.=(strlen($G) < 2?'0':'').$G; 
+        $Color.= (strlen($B) < 2?'0':'').$B;
+        
+        return($Color);
+    }
+
+    /**
+     * Reverse an array of points
+     * @param type $Plots
+     * @return type
+     */
+    public function reversePlots($Plots)
+    {
+        $Result = "";
+        for($i=count($Plots)-2;$i>=0;$i=$i-2) { 
+            $Result[] = $Plots[$i]; $Result[] = $Plots[$i+1];             
+        }
+        return($Result);
+    }
+
+    /**
+     * Mirror Effect
+     * @param type $X
+     * @param type $Y
+     * @param type $Width
+     * @param type $Height
+     * @param type $Format
+     */
+    public function drawAreaMirror($X,$Y,$Width,$Height,$Format="")
+    {
+        $StartAlpha = isset($Format["StartAlpha"]) ? $Format["StartAlpha"] : 80;
+        $EndAlpha = isset($Format["EndAlpha"]) ? $Format["EndAlpha"] : 0;
+
+        $AlphaStep = ($StartAlpha-$EndAlpha)/$Height;
+
+        $Picture = imagecreatetruecolor($this->XSize,$this->YSize);
+        imagecopy($Picture,$this->Picture,0,0,0,0,$this->XSize,$this->YSize);
+
+        for ($i=1;$i<=$Height;$i++) {
+            if ($Y+($i-1) < $this->YSize && $Y-$i > 0) { 
+                imagecopymerge(
+                    $Picture,
+                    $this->Picture,
+                    $X,
+                    $Y+($i-1),
+                    $X,
+                    $Y-$i,
+                    $Width,
+                    1,
+                    $StartAlpha-$AlphaStep*$i
+                );             
+            }
+        }
+
+        imagecopy($this->Picture,$Picture,0,0,0,0,$this->XSize,$this->YSize);
+    }
+}

vendor/szymach/c-pchart/src/Classes/pIndicator.php

@@ -0,0 +1,264 @@
+<?php
+namespace CpChart\Classes;
+/*
+    pIndicator - class to draw indicators
+
+    Version     : 2.1.4
+    Made by     : Jean-Damien POGOLOTTI
+    Last Update : 19/01/2014
+
+    This file can be distributed under the license you can find at :
+
+                      http://www.pchart.net/license
+
+    You can find the whole class documentation on the pChart web site.
+*/
+class pIndicator
+{
+    public $pChartObject;
+
+    /**
+     * Constructor
+     * @param type $pChartObject
+     * @param type $pDataObject - added for compatibility with other classes
+     */
+    public function __construct($pChartObject, $pDataObject = null)
+    {
+        $this->pChartObject = $pChartObject;
+    }
+
+    /* Draw an indicator */
+    public function draw($X,$Y,$Width,$Height,$Format="")
+    {
+        $Values			= isset($Format["Values"]) ? $Format["Values"] : VOID;
+        $IndicatorSections	= isset($Format["IndicatorSections"]) ? $Format["IndicatorSections"] : null;
+        $ValueDisplay		= isset($Format["ValueDisplay"]) ? $Format["ValueDisplay"] : INDICATOR_VALUE_BUBBLE;
+        $SectionsMargin		= isset($Format["SectionsMargin"]) ? $Format["SectionsMargin"] : 4;
+        $DrawLeftHead		= isset($Format["DrawLeftHead"]) ? $Format["DrawLeftHead"] : true;
+        $DrawRightHead		= isset($Format["DrawRightHead"]) ? $Format["DrawRightHead"] : true;
+        $HeadSize		= isset($Format["HeadSize"]) ? $Format["HeadSize"] : floor($Height/4);
+        $TextPadding		= isset($Format["TextPadding"]) ? $Format["TextPadding"] : 4;
+        $CaptionLayout		= isset($Format["CaptionLayout"]) ? $Format["CaptionLayout"] : INDICATOR_CAPTION_EXTENDED;
+        $CaptionPosition	= isset($Format["CaptionPosition"]) ? $Format["CaptionPosition"] : INDICATOR_CAPTION_INSIDE;
+        $CaptionColorFactor	= isset($Format["CaptionColorFactor"]) ? $Format["CaptionColorFactor"] : null;
+        $CaptionR		= isset($Format["CaptionR"]) ? $Format["CaptionR"] : 255;
+        $CaptionG		= isset($Format["CaptionG"]) ? $Format["CaptionG"] : 255;
+        $CaptionB		= isset($Format["CaptionB"]) ? $Format["CaptionB"] : 255;
+        $CaptionAlpha		= isset($Format["CaptionAlpha"]) ? $Format["CaptionAlpha"] : 100;
+        $SubCaptionColorFactor	= isset($Format["SubCaptionColorFactor"]) ? $Format["SubCaptionColorFactor"] : null;
+        $SubCaptionR		= isset($Format["SubCaptionR"]) ? $Format["SubCaptionR"] : 50;
+        $SubCaptionG		= isset($Format["SubCaptionG"]) ? $Format["SubCaptionG"] : 50;
+        $SubCaptionB		= isset($Format["SubCaptionB"]) ? $Format["SubCaptionB"] : 50;
+        $SubCaptionAlpha	= isset($Format["SubCaptionAlpha"]) ? $Format["SubCaptionAlpha"] : 100;
+        $ValueFontName		= isset($Format["ValueFontName"]) ? $Format["ValueFontName"] : $this->pChartObject->FontName;
+        $ValueFontSize		= isset($Format["ValueFontSize"]) ? $Format["ValueFontSize"] : $this->pChartObject->FontSize;
+        $CaptionFontName	= isset($Format["CaptionFontName"]) ? $Format["CaptionFontName"] : $this->pChartObject->FontName;
+        $CaptionFontSize	= isset($Format["CaptionFontSize"]) ? $Format["CaptionFontSize"] : $this->pChartObject->FontSize;
+        $Unit			= isset($Format["Unit"]) ? $Format["Unit"] : "";
+
+        /* Convert the Values to display to an array if needed */
+        if ( !is_array($Values) ) { 
+            $Value = $Values; $Values = ""; 
+            $Values[] = $Value;             
+        }
+
+        /* No section, let's die */
+        if ( $IndicatorSections == null ) { 
+            return(0);             
+        }
+
+        /* Determine indicator visual configuration */
+        $OverallMin = $IndicatorSections[0]["End"]; $OverallMax = $IndicatorSections[0]["Start"];
+        foreach ($IndicatorSections as $Key => $Settings) {
+            if ( $Settings["End"] > $OverallMax )   { $OverallMax = $Settings["End"]; }
+            if ( $Settings["Start"] < $OverallMin ) { $OverallMin = $Settings["Start"]; }
+        }
+        $RealWidth = $Width - (count($IndicatorSections)-1)*$SectionsMargin;
+        $XScale    = $RealWidth / ($OverallMax-$OverallMin);
+
+        $X1 = $X; $ValuesPos = "";
+        foreach ($IndicatorSections as $Key => $Settings) {
+            $Color      = array("R"=>$Settings["R"],"G"=>$Settings["G"],"B"=>$Settings["B"]);
+            $Caption    = $Settings["Caption"];
+            $SubCaption = $Settings["Start"]." - ".$Settings["End"];
+
+            $X2 = $X1 + ($Settings["End"] - $Settings["Start"]) * $XScale;
+
+            if ( $Key == 0 && $DrawLeftHead ) {
+                $Poly = ""; 
+                $Poly[] = $X1-1; 
+                $Poly[] = $Y; 
+                $Poly[] = $X1-1; 
+                $Poly[] = $Y+$Height; 
+                $Poly[] = $X1-1-$HeadSize; 
+                $Poly[] = $Y+($Height/2);
+                $this->pChartObject->drawPolygon($Poly,$Color);
+                $this->pChartObject->drawLine($X1-2,$Y,$X1-2-$HeadSize,$Y+($Height/2),$Color);
+                $this->pChartObject->drawLine($X1-2,$Y+$Height,$X1-2-$HeadSize,$Y+($Height/2),$Color);
+            }
+
+            /* Determine the position of the breaks */
+            $Break = "";
+            foreach($Values as $iKey => $Value) {
+                if ( $Value >= $Settings["Start"] && $Value <= $Settings["End"] ) {
+                    $XBreak  = $X1 + ($Value - $Settings["Start"]) * $XScale;
+                    $ValuesPos[$Value] = $XBreak;
+                    $Break[] = floor($XBreak);
+                }
+            }
+
+            if ( $ValueDisplay == INDICATOR_VALUE_LABEL )
+            {
+                if ( $Break == "" ) {
+                    $this->pChartObject->drawFilledRectangle($X1,$Y,$X2,$Y+$Height,$Color);
+                } else {
+                    sort($Break);
+                    $Poly = ""; $Poly[] = $X1; $Poly[] = $Y; $LastPointWritten = false;
+                    foreach($Break as $iKey => $Value) {
+                        if ( $Value-5 >= $X1 ) { 
+                            $Poly[] = $Value-5; $Poly[] = $Y;                             
+                        } elseif ($X1 - ($Value-5) > 0 ) {
+                            $Offset = $X1 - ($Value-5);
+                            $Poly = ""; $Poly[] = $X1; $Poly[] = $Y + $Offset;
+                        }
+
+                        $Poly[] = $Value;   $Poly[] = $Y+5;
+
+                        if ( $Value+5 <= $X2 ) { 
+                            $Poly[] = $Value+5; $Poly[] = $Y;                            
+                        } elseif (($Value+5) > $X2 ) {
+                            $Offset = ($Value+5) - $X2;
+                            $Poly[] = $X2; $Poly[] = $Y + $Offset;
+                            $LastPointWritten = true;
+                        }
+                    }
+                    if ( !$LastPointWritten ) { 
+                        $Poly[] = $X2; $Poly[] = $Y;                         
+                    }
+                    $Poly[] = $X2; $Poly[] = $Y+$Height;
+                    $Poly[] = $X1; $Poly[] = $Y+$Height;
+
+                    $this->pChartObject->drawPolygon($Poly,$Color);
+                }
+            } else {
+                $this->pChartObject->drawFilledRectangle($X1,$Y,$X2,$Y+$Height,$Color);
+            }
+            
+            if ( $Key == count($IndicatorSections)-1 && $DrawRightHead ) {
+                $Poly = ""; 
+                $Poly[] = $X2+1; 
+                $Poly[] = $Y; 
+                $Poly[] = $X2+1; 
+                $Poly[] = $Y+$Height; 
+                $Poly[] = $X2+1+$HeadSize; 
+                $Poly[] = $Y+($Height/2);
+                $this->pChartObject->drawPolygon($Poly,$Color);
+                $this->pChartObject->drawLine($X2+1,$Y,$X2+1+$HeadSize,$Y+($Height/2),$Color);
+                $this->pChartObject->drawLine($X2+1,$Y+$Height,$X2+1+$HeadSize,$Y+($Height/2),$Color);
+            }
+
+            if ( $CaptionPosition == INDICATOR_CAPTION_INSIDE ) {
+                $TxtPos  = $this->pChartObject->getTextBox($X1,$Y+$Height+$TextPadding,$CaptionFontName,$CaptionFontSize,0,$Caption);
+                $YOffset = ($TxtPos[0]["Y"] - $TxtPos[2]["Y"]) + $TextPadding;
+
+                if ( $CaptionLayout == INDICATOR_CAPTION_EXTENDED ) {
+                    $TxtPos  = $this->pChartObject->getTextBox($X1,$Y+$Height+$TextPadding,$CaptionFontName,$CaptionFontSize,0,$SubCaption);
+                    $YOffset = $YOffset + ($TxtPos[0]["Y"] - $TxtPos[2]["Y"]) + $TextPadding*2;
+                }
+                $XOffset = $TextPadding;
+            } else { 
+                $YOffset = 0; 
+                $XOffset = 0;                 
+            }
+
+            if ( $CaptionColorFactor == null ) { 
+                $CaptionColor = array(
+                    "Align"=>TEXT_ALIGN_TOPLEFT,
+                    "FontName"=>$CaptionFontName,
+                    "FontSize"=>$CaptionFontSize,
+                    "R"=>$CaptionR,
+                    "G"=>$CaptionG,
+                    "B"=>$CaptionB,
+                    "Alpha"=>$CaptionAlpha
+                );
+            } else { 
+                $CaptionColor = array(
+                    "Align"=>TEXT_ALIGN_TOPLEFT,
+                    "FontName"=>$CaptionFontName,
+                    "FontSize"=>$CaptionFontSize,
+                    "R"=>$Settings["R"]+$CaptionColorFactor,
+                    "G"=>$Settings["G"]+$CaptionColorFactor,
+                    "B"=>$Settings["B"]+$CaptionColorFactor
+                );                 
+            }
+
+            if ( $SubCaptionColorFactor == null ) {
+                $SubCaptionColor = array(
+                    "Align"=>TEXT_ALIGN_TOPLEFT,
+                    "FontName"=>$CaptionFontName,
+                    "FontSize"=>$CaptionFontSize,
+                    "R"=>$SubCaptionR,
+                    "G"=>$SubCaptionG,
+                    "B"=>$SubCaptionB,
+                    "Alpha"=>$SubCaptionAlpha
+                );
+            } else {
+                $SubCaptionColor = array(
+                    "Align"=>TEXT_ALIGN_TOPLEFT,
+                    "FontName"=>$CaptionFontName,
+                    "FontSize"=>$CaptionFontSize,
+                    "R"=>$Settings["R"]+$SubCaptionColorFactor,
+                    "G"=>$Settings["G"]+$SubCaptionColorFactor,
+                    "B"=>$Settings["B"]+$SubCaptionColorFactor
+                );
+            }
+            
+            $RestoreShadow = $this->pChartObject->Shadow;
+            $this->pChartObject->Shadow = false;
+
+            if ( $CaptionLayout == INDICATOR_CAPTION_DEFAULT ) {
+                $this->pChartObject->drawText($X1,$Y+$Height+$TextPadding,$Caption,$CaptionColor);
+            } elseif ( $CaptionLayout == INDICATOR_CAPTION_EXTENDED ) {
+                $TxtPos = $this->pChartObject->getTextBox($X1,$Y+$Height+$TextPadding,$CaptionFontName,$CaptionFontSize,0,$Caption);
+                $CaptionHeight = $TxtPos[0]["Y"] - $TxtPos[2]["Y"];
+
+                $this->pChartObject->drawText($X1+$XOffset,$Y+$Height-$YOffset+$TextPadding,$Caption,$CaptionColor);
+                $this->pChartObject->drawText($X1+$XOffset,$Y+$Height-$YOffset+$CaptionHeight+$TextPadding*2,$SubCaption,$SubCaptionColor);
+            }
+
+            $this->pChartObject->Shadow = $RestoreShadow;
+
+            $X1 = $X2 + $SectionsMargin;
+        }
+
+        $RestoreShadow = $this->pChartObject->Shadow;
+        $this->pChartObject->Shadow = false;
+
+        foreach($Values as $Key => $Value) {
+            if ( $Value >= $OverallMin && $Value <= $OverallMax ) {
+                foreach ($IndicatorSections as $Key => $Settings) {
+                    if ( $Value >= $Settings["Start"] && $Value <= $Settings["End"] ) {
+                        $X1 = $ValuesPos[$Value]; //$X + $Key*$SectionsMargin + ($Value - $OverallMin) * $XScale;
+
+                        if ( $ValueDisplay == INDICATOR_VALUE_BUBBLE ) {
+                            $TxtPos = $this->pChartObject->getTextBox($X1,$Y,$ValueFontName,$ValueFontSize,0,$Value.$Unit);
+                            $Radius = floor(($TxtPos[1]["X"] - $TxtPos[0]["X"] + $TextPadding*4)/2);
+
+                            $this->pChartObject->drawFilledCircle($X1,$Y,$Radius+4,array("R"=>$Settings["R"]+20,"G"=>$Settings["G"]+20,"B"=>$Settings["B"]+20));
+                            $this->pChartObject->drawFilledCircle($X1,$Y,$Radius,array("R"=>255,"G"=>255,"B"=>255));
+
+                            $TextSettings = array("Align"=>TEXT_ALIGN_MIDDLEMIDDLE,"FontName"=>$ValueFontName,"FontSize"=>$ValueFontSize);
+                            $this->pChartObject->drawText($X1-1,$Y-1,$Value.$Unit,$TextSettings);
+                        } elseif( $ValueDisplay == INDICATOR_VALUE_LABEL ) {
+                            $Caption = "";
+                            $Caption[] = array("Format"=>array("R"=>$Settings["R"],"G"=>$Settings["G"],"B"=>$Settings["B"],"Alpha"=>100),"Caption"=>$Value.$Unit);
+                            $this->pChartObject->drawLabelBox(floor($X1),floor($Y)+2,"Value - ".$Settings["Caption"],$Caption);
+                        }
+                    }
+                   $X1 = $X2 + $SectionsMargin;
+                }
+            }
+        }
+        $this->pChartObject->Shadow = $RestoreShadow;
+    }
+}

vendor/szymach/c-pchart/src/Classes/pRadar.php

@@ -0,0 +1,887 @@
+<?php
+namespace CpChart\Classes;
+/*
+    pRadar - class to draw radar charts
+
+    Version     : 2.1.4
+    Made by     : Jean-Damien POGOLOTTI
+    Last Update : 19/01/2014
+
+    This file can be distributed under the license you can find at :
+
+                      http://www.pchart.net/license
+
+    You can find the whole class documentation on the pChart web site.
+*/
+class pRadar
+{
+    public $pChartObject;
+
+    /**
+     * Draw a radar chart
+     * @param type $Object
+     * @param type $Values
+     * @param type $Format
+     */
+    public function drawRadar($Object,$Values,$Format="")
+    {
+        $this->pChartObject = $Object;
+
+        $FixedMax           = isset($Format["FixedMax"]) ? $Format["FixedMax"] : VOID;
+        $AxisR              = isset($Format["AxisR"]) ? $Format["AxisR"] : 60;
+        $AxisG              = isset($Format["AxisG"]) ? $Format["AxisG"] : 60;
+        $AxisB              = isset($Format["AxisB"]) ? $Format["AxisB"] : 60;
+        $AxisAlpha          = isset($Format["AxisAlpha"]) ? $Format["AxisAlpha"] : 50;
+        $AxisRotation       = isset($Format["AxisRotation"]) ? $Format["AxisRotation"] : 0;
+        $DrawTicks          = isset($Format["DrawTicks"]) ? $Format["DrawTicks"] : true;
+        $TicksLength        = isset($Format["TicksLength"]) ? $Format["TicksLength"] : 2;
+        $DrawAxisValues     = isset($Format["DrawAxisValues"]) ? $Format["DrawAxisValues"] : true;
+        $AxisBoxRounded     = isset($Format["AxisBoxRounded"]) ? $Format["AxisBoxRounded"] : true;
+        $AxisFontName       = isset($Format["AxisFontName"]) ? $Format["AxisFontName"] : $this->pChartObject->FontName;
+        $AxisFontSize       = isset($Format["AxisFontSize"]) ? $Format["AxisFontSize"] : $this->pChartObject->FontSize;
+        $WriteValues        = isset($Format["WriteValues"]) ? $Format["WriteValues"] : false;
+        $WriteValuesInBubble = isset($Format["WriteValuesInBubble"]) ? $Format["WriteValuesInBubble"] : true;
+        $ValueFontName      = isset($Format["ValueFontName"]) ? $Format["ValueFontName"] : $this->pChartObject->FontName;
+        $ValueFontSize      = isset($Format["ValueFontSize"]) ? $Format["ValueFontSize"] : $this->pChartObject->FontSize;
+        $ValuePadding       = isset($Format["ValuePadding"]) ? $Format["ValuePadding"] : 4;
+        $OuterBubbleRadius  = isset($Format["OuterBubbleRadius"]) ? $Format["OuterBubbleRadius"] : 2;
+        $OuterBubbleR       = isset($Format["OuterBubbleR"]) ? $Format["OuterBubbleR"] : VOID;
+        $OuterBubbleG       = isset($Format["OuterBubbleG"]) ? $Format["OuterBubbleG"] : VOID;
+        $OuterBubbleB       = isset($Format["OuterBubbleB"]) ? $Format["OuterBubbleB"] : VOID;
+        $OuterBubbleAlpha   = isset($Format["OuterBubbleAlpha"]) ? $Format["OuterBubbleAlpha"] : 100;
+        $InnerBubbleR       = isset($Format["InnerBubbleR"]) ? $Format["InnerBubbleR"] : 255;
+        $InnerBubbleG       = isset($Format["InnerBubbleG"]) ? $Format["InnerBubbleG"] : 255;
+        $InnerBubbleB       = isset($Format["InnerBubbleB"]) ? $Format["InnerBubbleB"] : 255;
+        $InnerBubbleAlpha   = isset($Format["InnerBubbleAlpha"]) ? $Format["InnerBubbleAlpha"] : 100;
+        $DrawBackground     = isset($Format["DrawBackground"]) ? $Format["DrawBackground"] : true;
+        $BackgroundR        = isset($Format["BackgroundR"]) ? $Format["BackgroundR"] : 255;
+        $BackgroundG        = isset($Format["BackgroundG"]) ? $Format["BackgroundG"] : 255;
+        $BackgroundB        = isset($Format["BackgroundB"]) ? $Format["BackgroundB"] : 255;
+        $BackgroundAlpha    = isset($Format["BackgroundAlpha"]) ? $Format["BackgroundAlpha"] : 50;
+        $BackgroundGradient = isset($Format["BackgroundGradient"]) ? $Format["BackgroundGradient"] : null;
+        $Layout             = isset($Format["Layout"]) ? $Format["Layout"] : RADAR_LAYOUT_STAR;
+        $SegmentHeight      = isset($Format["SegmentHeight"]) ? $Format["SegmentHeight"] : SEGMENT_HEIGHT_AUTO;
+        $Segments           = isset($Format["Segments"]) ? $Format["Segments"] : 4;
+        $WriteLabels        = isset($Format["WriteLabels"]) ? $Format["WriteLabels"] : true;
+        $SkipLabels         = isset($Format["SkipLabels"]) ? $Format["SkipLabels"] : 1;
+        $LabelMiddle        = isset($Format["LabelMiddle"]) ? $Format["LabelMiddle"] : false;
+        $LabelsBackground   = isset($Format["LabelsBackground"]) ? $Format["LabelsBackground"] : true;
+        $LabelsBGR          = isset($Format["LabelsBGR"]) ? $Format["LabelsBGR"] : 255;
+        $LabelsBGG          = isset($Format["LabelsBGR"]) ? $Format["LabelsBGG"] : 255;
+        $LabelsBGB          = isset($Format["LabelsBGR"]) ? $Format["LabelsBGB"] : 255;
+        $LabelsBGAlpha      = isset($Format["LabelsBGAlpha"]) ? $Format["LabelsBGAlpha"] : 50;
+        $LabelPos           = isset($Format["LabelPos"]) ? $Format["LabelPos"] : RADAR_LABELS_ROTATED;
+        $LabelPadding       = isset($Format["LabelPadding"]) ? $Format["LabelPadding"] : 4;
+        $DrawPoints         = isset($Format["DrawPoints"]) ? $Format["DrawPoints"] : true;
+        $PointRadius        = isset($Format["PointRadius"]) ? $Format["PointRadius"] : 4;
+        $PointSurrounding   = isset($Format["PointRadius"]) ? $Format["PointRadius"] : -30;
+        $DrawLines          = isset($Format["DrawLines"]) ? $Format["DrawLines"] : true;
+        $LineLoopStart      = isset($Format["LineLoopStart"]) ? $Format["LineLoopStart"] : true;
+        $DrawPoly           = isset($Format["DrawPoly"]) ? $Format["DrawPoly"] : false;
+        $PolyAlpha          = isset($Format["PolyAlpha"]) ? $Format["PolyAlpha"] : 40;
+        $FontSize           = $Object->FontSize;
+        $X1                 = $Object->GraphAreaX1;
+        $Y1                 = $Object->GraphAreaY1;
+        $X2                 = $Object->GraphAreaX2;
+        $Y2                 = $Object->GraphAreaY2;
+        $RecordImageMap     = isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : false;
+
+        /* Cancel default tick length if ticks not enabled */
+        if ( $DrawTicks == false ) { 
+            $TicksLength = 0;             
+        }
+
+        /* Data Processing */
+        $Data    = $Values->getData();
+        $Palette = $Values->getPalette();
+
+        /* Catch the number of required axis */
+        $LabelSerie = $Data["Abscissa"];
+        if ( $LabelSerie != "" ) { 
+            $Points = count($Data["Series"][$LabelSerie]["Data"]);             
+        } else {
+            $Points = 0;
+            foreach($Data["Series"] as $SerieName => $DataArray) { 
+                if ( count($DataArray["Data"]) > $Points ) { 
+                    $Points = count($DataArray["Data"]);                     
+                }
+            }
+        }
+
+        /* Draw the axis */
+        $CenterX = ($X2-$X1)/2 + $X1;
+        $CenterY = ($Y2-$Y1)/2 + $Y1;
+
+        $EdgeHeight = min(($X2-$X1)/2,($Y2-$Y1)/2);
+        if ( $WriteLabels ) {
+            $EdgeHeight = $EdgeHeight - $FontSize - $LabelPadding - $TicksLength;
+        }
+        /* Determine the scale if set to automatic */
+        if ( $SegmentHeight == SEGMENT_HEIGHT_AUTO) {
+            if ( $FixedMax != VOID ) {
+                $Max = $FixedMax;
+            } else {
+                $Max = 0;
+                foreach($Data["Series"] as $SerieName => $DataArray) {
+                    if ( $SerieName != $LabelSerie ) {
+                        if ( max($DataArray["Data"]) > $Max ) { 
+                            $Max = max($DataArray["Data"]);                             
+                        }
+                    }
+                }
+            }
+            $MaxSegments = $EdgeHeight/20;
+            $Scale = $Object->computeScale(0,$Max,$MaxSegments,array(1,2,5));
+
+            $Segments      = $Scale["Rows"];
+            $SegmentHeight = $Scale["RowHeight"];
+        }
+
+        if ( $LabelMiddle && $SkipLabels == 1 ) { 
+            $Axisoffset = (360/$Points)/2;             
+        } elseif ( $LabelMiddle && $SkipLabels != 1 ) { 
+            $Axisoffset = (360/($Points/$SkipLabels))/2;             
+        } elseif ( !$LabelMiddle ) { 
+            $Axisoffset = 0;             
+        }
+
+        /* Background processing */
+        if ( $DrawBackground ) {
+            $RestoreShadow = $Object->Shadow;
+            $Object->Shadow = false;
+
+            if ($BackgroundGradient == null) {
+                if ( $Layout == RADAR_LAYOUT_STAR ) {
+                    $Color = array("R"=>$BackgroundR,"G"=>$BackgroundG,"B"=>$BackgroundB,"Alpha"=>$BackgroundAlpha);
+                    $PointArray = "";
+                    for($i=0;$i<=360;$i=$i+(360/$Points)) {
+                        $PointArray[] = cos(deg2rad($i+$AxisRotation)) * $EdgeHeight + $CenterX;
+                        $PointArray[] = sin(deg2rad($i+$AxisRotation)) * $EdgeHeight + $CenterY;
+                    }
+                    $Object->drawPolygon($PointArray,$Color);
+                } elseif ( $Layout == RADAR_LAYOUT_CIRCLE ) {
+                    $Color = array("R"=>$BackgroundR,"G"=>$BackgroundG,"B"=>$BackgroundB,"Alpha"=>$BackgroundAlpha);
+                    $Object->drawFilledCircle($CenterX,$CenterY,$EdgeHeight,$Color);
+                }
+            } else {
+                $GradientROffset	= ($BackgroundGradient["EndR"] - $BackgroundGradient["StartR"]) / $Segments;
+                $GradientGOffset	= ($BackgroundGradient["EndG"] - $BackgroundGradient["StartG"]) / $Segments;
+                $GradientBOffset	= ($BackgroundGradient["EndB"] - $BackgroundGradient["StartB"]) / $Segments;
+                $GradientAlphaOffset	= ($BackgroundGradient["EndAlpha"] - $BackgroundGradient["StartAlpha"]) / $Segments;
+
+                if ( $Layout == RADAR_LAYOUT_STAR ) {
+                    for ($j=$Segments;$j>=1;$j--) {
+                        $Color = array(
+                            "R"=>$BackgroundGradient["StartR"]+$GradientROffset*$j,
+                            "G"=>$BackgroundGradient["StartG"]+$GradientGOffset*$j,
+                            "B"=>$BackgroundGradient["StartB"]+$GradientBOffset*$j,
+                            "Alpha"=>$BackgroundGradient["StartAlpha"]+$GradientAlphaOffset*$j
+                        );
+                        $PointArray = "";
+
+                        for($i=0;$i<=360;$i=$i+(360/$Points)) {
+                            $PointArray[] = cos(deg2rad($i+$AxisRotation)) * ($EdgeHeight/$Segments)*$j + $CenterX;
+                            $PointArray[] = sin(deg2rad($i+$AxisRotation)) * ($EdgeHeight/$Segments)*$j + $CenterY;
+                        }
+                        $Object->drawPolygon($PointArray,$Color);
+                    }
+                } elseif ( $Layout == RADAR_LAYOUT_CIRCLE ) {
+                    for($j=$Segments;$j>=1;$j--) {
+                        $Color = array(
+                            "R"=>$BackgroundGradient["StartR"]+$GradientROffset*$j,
+                            "G"=>$BackgroundGradient["StartG"]+$GradientGOffset*$j,
+                            "B"=>$BackgroundGradient["StartB"]+$GradientBOffset*$j,
+                            "Alpha"=>$BackgroundGradient["StartAlpha"]+$GradientAlphaOffset*$j
+                        );
+                        $Object->drawFilledCircle($CenterX,$CenterY,($EdgeHeight/$Segments)*$j,$Color);
+                    }
+                }
+            }
+            $Object->Shadow = $RestoreShadow;
+        }
+
+        /* Axis to axis lines */
+        $Color = array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha);
+        $ColorDotted = array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha*.8, "Ticks"=>2);
+        if ( $Layout == RADAR_LAYOUT_STAR ) {
+            for($j=1;$j<=$Segments;$j++) {
+                for($i=0;$i<360;$i=$i+(360/$Points)) {
+                    $EdgeX1 = cos(deg2rad($i+$AxisRotation)) * ($EdgeHeight/$Segments)*$j + $CenterX;
+                    $EdgeY1 = sin(deg2rad($i+$AxisRotation)) * ($EdgeHeight/$Segments)*$j + $CenterY;
+                    $EdgeX2 = cos(deg2rad($i+$AxisRotation+(360/$Points))) * ($EdgeHeight/$Segments)*$j + $CenterX;
+                    $EdgeY2 = sin(deg2rad($i+$AxisRotation+(360/$Points))) * ($EdgeHeight/$Segments)*$j + $CenterY;
+
+                    $Object->drawLine($EdgeX1,$EdgeY1,$EdgeX2,$EdgeY2,$Color);
+                }
+            }
+        } elseif ( $Layout == RADAR_LAYOUT_CIRCLE ) {
+            for($j=1;$j<=$Segments;$j++) {
+                $Radius = ($EdgeHeight/$Segments)*$j;
+                $Object->drawCircle($CenterX,$CenterY,$Radius,$Radius,$Color);
+            }
+        }
+
+        if ( $DrawAxisValues ) {
+            if ( $LabelsBackground ) {
+                $Options = array(
+                    "DrawBox"=>true, 
+                    "Align"=>TEXT_ALIGN_MIDDLEMIDDLE,
+                    "BoxR"=>$LabelsBGR,
+                    "BoxG"=>$LabelsBGG,
+                    "BoxB"=>$LabelsBGB,
+                    "BoxAlpha"=>$LabelsBGAlpha
+                );
+            } else {
+                $Options = array("Align"=>TEXT_ALIGN_MIDDLEMIDDLE);
+            }
+            if ( $AxisBoxRounded ) { 
+                $Options["BoxRounded"] = true;                 
+            }
+
+            $Options["FontName"] = $AxisFontName;
+            $Options["FontSize"] = $AxisFontSize;
+
+            $Angle  = 360 / ($Points*2);
+            for($j=1;$j<=$Segments;$j++) {
+                $Label  = $j * $SegmentHeight;
+
+                if ( $Layout == RADAR_LAYOUT_CIRCLE ) {
+                    $EdgeX1 = cos(deg2rad($Angle+$AxisRotation)) * ($EdgeHeight/$Segments)*$j + $CenterX;
+                    $EdgeY1 = sin(deg2rad($Angle+$AxisRotation)) * ($EdgeHeight/$Segments)*$j + $CenterY;
+                } elseif ( $Layout == RADAR_LAYOUT_STAR ) {
+                    $EdgeX1 = cos(deg2rad($AxisRotation)) * ($EdgeHeight/$Segments)*$j + $CenterX;
+                    $EdgeY1 = sin(deg2rad($AxisRotation)) * ($EdgeHeight/$Segments)*$j + $CenterY;
+                    $EdgeX2 = cos(deg2rad((360 / $Points) + $AxisRotation)) * ($EdgeHeight/$Segments)*$j + $CenterX;
+                    $EdgeY2 = sin(deg2rad((360 / $Points) + $AxisRotation)) * ($EdgeHeight/$Segments)*$j + $CenterY;
+
+                    $EdgeX1 = ($EdgeX2 - $EdgeX1)/2 + $EdgeX1;
+                    $EdgeY1 = ($EdgeY2 - $EdgeY1)/2 + $EdgeY1;
+                }
+
+                $Object->drawText($EdgeX1,$EdgeY1,$Label,$Options);
+            }
+        }
+
+        /* Axis lines */
+        $ID = 0;
+        for($i=0;$i<360;$i=$i+(360/$Points)) {
+            $EdgeX = cos(deg2rad($i+$AxisRotation)) * ($EdgeHeight+$TicksLength) + $CenterX;
+            $EdgeY = sin(deg2rad($i+$AxisRotation)) * ($EdgeHeight+$TicksLength) + $CenterY;
+
+            if ($ID % $SkipLabels == 0) { 
+                $Object->drawLine($CenterX,$CenterY,$EdgeX,$EdgeY,$Color);
+            } else { 
+                $Object->drawLine($CenterX,$CenterY,$EdgeX,$EdgeY,$ColorDotted);                 
+            }
+
+            if ( $WriteLabels ) {
+                $LabelX = cos(deg2rad($i+$AxisRotation+$Axisoffset)) * ($EdgeHeight+$LabelPadding+$TicksLength) + $CenterX;
+                $LabelY = sin(deg2rad($i+$AxisRotation+$Axisoffset)) * ($EdgeHeight+$LabelPadding+$TicksLength) + $CenterY;
+
+                if ( $LabelSerie != "" ) { 
+                    $Label = isset($Data["Series"][$LabelSerie]["Data"][$ID]) ? $Data["Series"][$LabelSerie]["Data"][$ID] : "";
+                } else {
+                    $Label = $ID;
+                }
+                
+                if ($ID % $SkipLabels == 0) {
+                    if ( $LabelPos == RADAR_LABELS_ROTATED ) {
+                        $Object->drawText(
+                            $LabelX,
+                            $LabelY,
+                            $Label,
+                            array(
+                                "Angle"=>(360-($i+$AxisRotation+$Axisoffset))-90,
+                                "Align"=>TEXT_ALIGN_BOTTOMMIDDLE
+                            )
+                        );
+                    } else {
+                        if ( (floor($LabelX) == floor($CenterX)) && (floor($LabelY) <  floor($CenterY)) ) { 
+                            $Object->drawText($LabelX,$LabelY,$Label,array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE));                             
+                        }
+                        if ( (floor($LabelX) >  floor($CenterX)) && (floor($LabelY) <  floor($CenterY)) ) { 
+                            $Object->drawText($LabelX,$LabelY,$Label,array("Align"=>TEXT_ALIGN_BOTTOMLEFT));
+                        }
+                        if ( (floor($LabelX) >  floor($CenterX)) && (floor($LabelY) == floor($CenterY)) ) { 
+                            $Object->drawText($LabelX,$LabelY,$Label,array("Align"=>TEXT_ALIGN_MIDDLELEFT));                             
+                        }
+                        if ( (floor($LabelX) >  floor($CenterX)) && (floor($LabelY) >  floor($CenterY)) ) { 
+                            $Object->drawText($LabelX,$LabelY,$Label,array("Align"=>TEXT_ALIGN_TOPLEFT));                             
+                        }
+                        if ( (floor($LabelX) <  floor($CenterX)) && (floor($LabelY) <  floor($CenterY)) ) { 
+                            $Object->drawText($LabelX,$LabelY,$Label,array("Align"=>TEXT_ALIGN_BOTTOMRIGHT));                             
+                        }
+                        if ( (floor($LabelX) <  floor($CenterX)) && (floor($LabelY) == floor($CenterY)) ) { 
+                            $Object->drawText($LabelX,$LabelY,$Label,array("Align"=>TEXT_ALIGN_MIDDLERIGHT));                             
+                        }
+                        if ( (floor($LabelX) <  floor($CenterX)) && (floor($LabelY) >  floor($CenterY)) ) { 
+                            $Object->drawText($LabelX,$LabelY,$Label,array("Align"=>TEXT_ALIGN_TOPRIGHT));                             
+                        }
+                        if ( (floor($LabelX) == floor($CenterX)) && (floor($LabelY) >  floor($CenterY)) ) { 
+                            $Object->drawText($LabelX,$LabelY,$Label,array("Align"=>TEXT_ALIGN_TOPMIDDLE));
+                        }
+                    }
+                }
+            }
+            $ID++;
+        }
+
+        /* Compute the plots position */
+        $ID = 0; $Plot = "";
+        foreach($Data["Series"] as $SerieName => $DataS) {
+            if ( $SerieName != $LabelSerie ) {
+                $Color = array(
+                    "R"=>$Palette[$ID]["R"],
+                    "G"=>$Palette[$ID]["G"],
+                    "B"=>$Palette[$ID]["B"],
+                    "Alpha"=>$Palette[$ID]["Alpha"],
+                    "Surrounding"=>$PointSurrounding
+                );
+                foreach($DataS["Data"] as $Key => $Value) {
+                    $Angle  = (360/$Points) * $Key;
+                    $Length = ($EdgeHeight/($Segments*$SegmentHeight))*$Value;
+
+                    $X = cos(deg2rad($Angle+$AxisRotation)) * $Length  + $CenterX;
+                    $Y = sin(deg2rad($Angle+$AxisRotation)) * $Length  + $CenterY;
+
+                    $Plot[$ID][] = array($X,$Y,$Value);
+
+                    if ( $RecordImageMap ) { 
+                        $this->pChartObject->addToImageMap(
+                            "CIRCLE",
+                            floor($X).",".floor($Y).",".floor($PointRadius),
+                            $this->pChartObject->toHTMLColor(
+                                $Palette[$ID]["R"],
+                                $Palette[$ID]["G"],
+                                $Palette[$ID]["B"]
+                            ),
+                            $DataS["Description"],
+                            $Data["Series"][$LabelSerie]["Data"][$Key]." = ".$Value
+                        );                         
+                    }
+                }
+                $ID++;
+            }
+        }
+
+        /* Draw all that stuff! */
+        foreach($Plot as $ID => $Points) {
+            $Color = array(
+                "R"=>$Palette[$ID]["R"],
+                "G"=>$Palette[$ID]["G"],
+                "B"=>$Palette[$ID]["B"],
+                "Alpha"=>$Palette[$ID]["Alpha"],
+                "Surrounding"=>$PointSurrounding
+            );
+
+            /* Draw the polygons */
+            if ( $DrawPoly ) {
+                if ($PolyAlpha != null) {
+                    $Color = array(
+                        "R"=>$Palette[$ID]["R"],
+                        "G"=>$Palette[$ID]["G"],
+                        "B"=>$Palette[$ID]["B"],
+                        "Alpha"=>$PolyAlpha,
+                        "Surrounding"=>$PointSurrounding
+                    );
+                }
+                $PointsArray = "";
+                for ($i=0; $i<count($Points);$i++) { 
+                    $PointsArray[] = $Points[$i][0]; 
+                    $PointsArray[] = $Points[$i][1];                     
+                }
+                $Object->drawPolygon($PointsArray,$Color);
+            }
+
+            $Color = array(
+                "R"=>$Palette[$ID]["R"],
+                "G"=>$Palette[$ID]["G"],
+                "B"=>$Palette[$ID]["B"],
+                "Alpha"=>$Palette[$ID]["Alpha"],
+                "Surrounding"=>$PointSurrounding
+            );
+
+            /* Bubble and labels settings */
+            $TextSettings = array(
+                "Align"=>TEXT_ALIGN_MIDDLEMIDDLE,
+                "FontName"=>$ValueFontName,
+                "FontSize"=>$ValueFontSize,
+                "R"=>$Palette[$ID]["R"],
+                "G"=>$Palette[$ID]["G"],
+                "B"=>$Palette[$ID]["B"]
+            );
+            $InnerColor = array(
+                "R"=>$InnerBubbleR,
+                "G"=>$InnerBubbleG,
+                "B"=>$InnerBubbleB,
+                "Alpha"=>$InnerBubbleAlpha
+            );
+            if ( $OuterBubbleR != VOID ) {
+                $OuterColor = array(
+                    "R"=>$OuterBubbleR,
+                    "G"=>$OuterBubbleG,
+                    "B"=>$OuterBubbleB,
+                    "Alpha"=>$OuterBubbleAlpha
+                );
+            } else {
+                $OuterColor = array(
+                    "R"=>$Palette[$ID]["R"]+20,
+                    "G"=>$Palette[$ID]["G"]+20,
+                    "B"=>$Palette[$ID]["B"]+20,
+                    "Alpha"=>$Palette[$ID]["Alpha"]
+                );
+            }
+       /* Loop to the starting points if asked */
+       if ( $LineLoopStart && $DrawLines )
+        $Object->drawLine(
+            $Points[count($Points)-1][0],
+            $Points[count($Points)-1][1],
+            $Points[0][0],
+            $Points[0][1],
+            $Color
+        );
+
+        /* Draw the lines & points */
+        for ($i=0; $i<count($Points);$i++) {
+            if ( $DrawLines && $i < count($Points)-1) {
+                $Object->drawLine(
+                    $Points[$i][0],
+                    $Points[$i][1],
+                    $Points[$i+1][0],
+                    $Points[$i+1][1],
+                    $Color
+                );
+            }
+            if ( $DrawPoints ) {
+                $Object->drawFilledCircle(
+                    $Points[$i][0],
+                    $Points[$i][1],
+                    $PointRadius,
+                    $Color
+                );
+            }
+            if ( $WriteValuesInBubble && $WriteValues ) {
+                $TxtPos = $this->pChartObject->getTextBox(
+                    $Points[$i][0],
+                    $Points[$i][1],
+                    $ValueFontName,
+                    $ValueFontSize,
+                    0,
+                    $Points[$i][2]
+                );
+                $Radius = floor(($TxtPos[1]["X"] - $TxtPos[0]["X"] + $ValuePadding*2)/2);
+
+                $this->pChartObject->drawFilledCircle(
+                    $Points[$i][0],
+                    $Points[$i][1],
+                    $Radius+$OuterBubbleRadius,
+                    $OuterColor
+                );
+                $this->pChartObject->drawFilledCircle(
+                    $Points[$i][0],
+                    $Points[$i][1],
+                    $Radius,$InnerColor
+                );
+            }
+
+            if ( $WriteValues )
+                $this->pChartObject->drawText(
+                    $Points[$i][0]-1,
+                    $Points[$i][1]-1,
+                    $Points[$i][2],
+                    $TextSettings
+                );
+            }
+        }
+    }
+
+
+
+    /**
+     * Draw a radar chart
+     * @param type $Object
+     * @param type $Values
+     * @param type $Format
+     */
+    public function drawPolar($Object,$Values,$Format="")
+    {
+        $this->pChartObject = $Object;
+
+        $FixedMax       = isset($Format["FixedMax"]) ? $Format["FixedMax"] : VOID;
+        $AxisR		= isset($Format["AxisR"]) ? $Format["AxisR"] : 60;
+        $AxisG		= isset($Format["AxisG"]) ? $Format["AxisG"] : 60;
+        $AxisB		= isset($Format["AxisB"]) ? $Format["AxisB"] : 60;
+        $AxisAlpha	= isset($Format["AxisAlpha"]) ? $Format["AxisAlpha"] : 50;
+        $AxisRotation   = isset($Format["AxisRotation"]) ? $Format["AxisRotation"] : -90;
+        $DrawTicks	= isset($Format["DrawTicks"]) ? $Format["DrawTicks"] : true;
+        $TicksLength	= isset($Format["TicksLength"]) ? $Format["TicksLength"] : 2;
+        $DrawAxisValues	= isset($Format["DrawAxisValues"]) ? $Format["DrawAxisValues"] : true;
+        $AxisBoxRounded	= isset($Format["AxisBoxRounded"]) ? $Format["AxisBoxRounded"] : true;
+        $AxisFontName	= isset($Format["FontName"]) ? $Format["FontName"] : $this->pChartObject->FontName;
+        $AxisFontSize	= isset($Format["FontSize"]) ? $Format["FontSize"] : $this->pChartObject->FontSize;
+        $WriteValues	= isset($Format["WriteValues"]) ? $Format["WriteValues"] : false;
+        $WriteValuesInBubble = isset($Format["WriteValuesInBubble"]) ? $Format["WriteValuesInBubble"] : true;
+        $ValueFontName	= isset($Format["ValueFontName"]) ? $Format["ValueFontName"] : $this->pChartObject->FontName;
+        $ValueFontSize	= isset($Format["ValueFontSize"]) ? $Format["ValueFontSize"] : $this->pChartObject->FontSize;
+        $ValuePadding	= isset($Format["ValuePadding"]) ? $Format["ValuePadding"] : 4;
+        $OuterBubbleRadius = isset($Format["OuterBubbleRadius"]) ? $Format["OuterBubbleRadius"] : 2;
+        $OuterBubbleR	= isset($Format["OuterBubbleR"]) ? $Format["OuterBubbleR"] : VOID;
+        $OuterBubbleG	= isset($Format["OuterBubbleG"]) ? $Format["OuterBubbleG"] : VOID;
+        $OuterBubbleB	= isset($Format["OuterBubbleB"]) ? $Format["OuterBubbleB"] : VOID;
+        $OuterBubbleAlpha = isset($Format["OuterBubbleAlpha"]) ? $Format["OuterBubbleAlpha"] : 100;
+        $InnerBubbleR	= isset($Format["InnerBubbleR"]) ? $Format["InnerBubbleR"] : 255;
+        $InnerBubbleG	= isset($Format["InnerBubbleG"]) ? $Format["InnerBubbleG"] : 255;
+        $InnerBubbleB	= isset($Format["InnerBubbleB"]) ? $Format["InnerBubbleB"] : 255;
+        $InnerBubbleAlpha = isset($Format["InnerBubbleAlpha"]) ? $Format["InnerBubbleAlpha"] : 100;
+        $DrawBackground	= isset($Format["DrawBackground"]) ? $Format["DrawBackground"] : true;
+        $BackgroundR	= isset($Format["BackgroundR"]) ? $Format["BackgroundR"] : 255;
+        $BackgroundG	= isset($Format["BackgroundG"]) ? $Format["BackgroundG"] : 255;
+        $BackgroundB	= isset($Format["BackgroundB"]) ? $Format["BackgroundB"] : 255;
+        $BackgroundAlpha = isset($Format["BackgroundAlpha"]) ? $Format["BackgroundAlpha"] : 50;
+        $BackgroundGradient= isset($Format["BackgroundGradient"]) ? $Format["BackgroundGradient"] : null;
+        $AxisSteps	= isset($Format["AxisSteps"]) ? $Format["AxisSteps"] : 20;
+        $SegmentHeight	= isset($Format["SegmentHeight"]) ? $Format["SegmentHeight"] : SEGMENT_HEIGHT_AUTO;
+        $Segments	= isset($Format["Segments"]) ? $Format["Segments"] : 4;
+        $WriteLabels	= isset($Format["WriteLabels"]) ? $Format["WriteLabels"] : true;
+        $LabelsBackground = isset($Format["LabelsBackground"]) ? $Format["LabelsBackground"] : true;
+        $LabelsBGR	= isset($Format["LabelsBGR"]) ? $Format["LabelsBGR"] : 255;
+        $LabelsBGG	= isset($Format["LabelsBGR"]) ? $Format["LabelsBGG"] : 255;
+        $LabelsBGB	= isset($Format["LabelsBGR"]) ? $Format["LabelsBGB"] : 255;
+        $LabelsBGAlpha	= isset($Format["LabelsBGAlpha"]) ? $Format["LabelsBGAlpha"] : 50;
+        $LabelPos	= isset($Format["LabelPos"]) ? $Format["LabelPos"] : RADAR_LABELS_ROTATED;
+        $LabelPadding	= isset($Format["LabelPadding"]) ? $Format["LabelPadding"] : 4;
+        $DrawPoints	= isset($Format["DrawPoints"]) ? $Format["DrawPoints"] : true;
+        $PointRadius	= isset($Format["PointRadius"]) ? $Format["PointRadius"] : 4;
+        $PointSurrounding = isset($Format["PointRadius"]) ? $Format["PointRadius"] : -30;
+        $DrawLines	= isset($Format["DrawLines"]) ? $Format["DrawLines"] : true;
+        $LineLoopStart	= isset($Format["LineLoopStart"]) ? $Format["LineLoopStart"] : false;
+        $DrawPoly	= isset($Format["DrawPoly"]) ? $Format["DrawPoly"] : false;
+        $PolyAlpha	= isset($Format["PolyAlpha"]) ? $Format["PolyAlpha"] : null;
+        $FontSize	= $Object->FontSize;
+        $X1		= $Object->GraphAreaX1;
+        $Y1		= $Object->GraphAreaY1;
+        $X2		= $Object->GraphAreaX2;
+        $Y2		= $Object->GraphAreaY2;
+        $RecordImageMap	= isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : false;
+
+        if ( $AxisBoxRounded ) { 
+            $DrawAxisValues = true;             
+        }
+
+        /* Cancel default tick length if ticks not enabled */
+        if ( $DrawTicks == false ) { 
+            $TicksLength = 0;             
+        }
+
+        /* Data Processing */
+        $Data    = $Values->getData();
+        $Palette = $Values->getPalette();
+
+        /* Catch the number of required axis */
+        $LabelSerie = $Data["Abscissa"];
+        if ( $LabelSerie != "" ) { 
+            $Points = count($Data["Series"][$LabelSerie]["Data"]);             
+        } else {
+            $Points = 0;
+            foreach($Data["Series"] as $SerieName => $DataArray) { 
+                if ( count($DataArray["Data"]) > $Points ) { 
+                    $Points = count($DataArray["Data"]);                     
+                }                 
+            }
+        }
+
+        /* Draw the axis */
+        $CenterX = ($X2-$X1)/2 + $X1;
+        $CenterY = ($Y2-$Y1)/2 + $Y1;
+
+        $EdgeHeight = min(($X2-$X1)/2,($Y2-$Y1)/2);
+        if ( $WriteLabels ) {
+            $EdgeHeight = $EdgeHeight - $FontSize - $LabelPadding - $TicksLength;
+        }
+        
+        /* Determine the scale if set to automatic */
+        if ( $SegmentHeight == SEGMENT_HEIGHT_AUTO) {
+            if ( $FixedMax != VOID ) {
+                $Max = $FixedMax;
+            } else {
+                $Max = 0;
+                foreach($Data["Series"] as $SerieName => $DataArray) {
+                    if ( $SerieName != $LabelSerie ) {
+                        if ( max($DataArray["Data"]) > $Max ) { 
+                            $Max = max($DataArray["Data"]);                         
+                        }
+                    }
+                }
+            }
+            $MaxSegments = $EdgeHeight/20;
+            $Scale = $Object->computeScale(0,$Max,$MaxSegments,array(1,2,5));
+
+            $Segments      = $Scale["Rows"];
+            $SegmentHeight = $Scale["RowHeight"];
+        }
+
+
+        /* Background processing */
+        if ( $DrawBackground ) {
+            $RestoreShadow = $Object->Shadow;
+            $Object->Shadow = false;
+
+            if ($BackgroundGradient == null) {
+                $Color = array("R"=>$BackgroundR,"G"=>$BackgroundG,"B"=>$BackgroundB,"Alpha"=>$BackgroundAlpha);
+                $Object->drawFilledCircle($CenterX,$CenterY,$EdgeHeight,$Color);
+            } else {
+                $GradientROffset	= ($BackgroundGradient["EndR"] - $BackgroundGradient["StartR"]) / $Segments;
+                $GradientGOffset	= ($BackgroundGradient["EndG"] - $BackgroundGradient["StartG"]) / $Segments;
+                $GradientBOffset	= ($BackgroundGradient["EndB"] - $BackgroundGradient["StartB"]) / $Segments;
+                $GradientAlphaOffset	= ($BackgroundGradient["EndAlpha"] - $BackgroundGradient["StartAlpha"]) / $Segments;
+
+                for ($j=$Segments;$j>=1;$j--) {
+                    $Color = array(
+                        "R"=>$BackgroundGradient["StartR"]+$GradientROffset*$j,
+                        "G"=>$BackgroundGradient["StartG"]+$GradientGOffset*$j,
+                        "B"=>$BackgroundGradient["StartB"]+$GradientBOffset*$j,
+                        "Alpha"=>$BackgroundGradient["StartAlpha"]+$GradientAlphaOffset*$j
+                    );
+                    $Object->drawFilledCircle($CenterX,$CenterY,($EdgeHeight/$Segments)*$j,$Color);
+                }
+            }
+            $Object->Shadow = $RestoreShadow;
+        }
+
+        /* Axis to axis lines */
+        $Color = array("R"=>$AxisR,"G"=>$AxisG,"B"=>$AxisB,"Alpha"=>$AxisAlpha);
+        for($j=1;$j<=$Segments;$j++) {
+            $Radius = ($EdgeHeight/$Segments)*$j;
+            $Object->drawCircle($CenterX,$CenterY,$Radius,$Radius,$Color);
+        }
+
+        if ( $DrawAxisValues ) {
+            if ( $LabelsBackground ) {
+                $Options = array(
+                    "DrawBox"=>true, 
+                    "Align"=>TEXT_ALIGN_MIDDLEMIDDLE,
+                    "BoxR"=>$LabelsBGR,
+                    "BoxG"=>$LabelsBGG,
+                    "BoxB"=>$LabelsBGB,
+                    "BoxAlpha"=>$LabelsBGAlpha
+                );
+            } else {
+                $Options = array("Align"=>TEXT_ALIGN_MIDDLEMIDDLE);
+            }
+            
+            if ( $AxisBoxRounded ) { $Options["BoxRounded"] = true; }
+
+            $Options["FontName"] = $AxisFontName;
+            $Options["FontSize"] = $AxisFontSize;
+
+            $Angle  = 360 / ($Points*2);
+            for($j=1;$j<=$Segments;$j++) {
+                $EdgeX1 = cos(deg2rad($Angle+$AxisRotation)) * ($EdgeHeight/$Segments)*$j + $CenterX;
+                $EdgeY1 = sin(deg2rad($Angle+$AxisRotation)) * ($EdgeHeight/$Segments)*$j + $CenterY;
+                $Label  = $j*$SegmentHeight;
+
+                $Object->drawText($EdgeX1,$EdgeY1,$Label,$Options);
+            }
+        }
+
+        /* Axis lines */
+        $ID = 0;
+        for($i=0;$i<=359;$i=$i+$AxisSteps) {
+            $EdgeX = cos(deg2rad($i+$AxisRotation)) * ($EdgeHeight+$TicksLength) + $CenterX;
+            $EdgeY = sin(deg2rad($i+$AxisRotation)) * ($EdgeHeight+$TicksLength) + $CenterY;
+
+            $Object->drawLine($CenterX,$CenterY,$EdgeX,$EdgeY,$Color);
+
+            if ( $WriteLabels ) {
+                $LabelX = cos(deg2rad($i+$AxisRotation)) * ($EdgeHeight+$LabelPadding+$TicksLength) + $CenterX;
+                $LabelY = sin(deg2rad($i+$AxisRotation)) * ($EdgeHeight+$LabelPadding+$TicksLength) + $CenterY;
+                $Label = $i."°";
+
+                if ( $LabelPos == RADAR_LABELS_ROTATED ) {
+                    $Object->drawText($LabelX,$LabelY,$Label,array("Angle"=>(360-$i),"Align"=>TEXT_ALIGN_BOTTOMMIDDLE));
+                } else {
+                    if ( (floor($LabelX) == floor($CenterX)) && (floor($LabelY) <  floor($CenterY)) ) { 
+                        $Object->drawText($LabelX,$LabelY,$Label,array("Align"=>TEXT_ALIGN_BOTTOMMIDDLE));                         
+                    }
+                    if ( (floor($LabelX) >  floor($CenterX)) && (floor($LabelY) <  floor($CenterY)) ) { 
+                        $Object->drawText($LabelX,$LabelY,$Label,array("Align"=>TEXT_ALIGN_BOTTOMLEFT));                         
+                    }
+                    if ( (floor($LabelX) >  floor($CenterX)) && (floor($LabelY) == floor($CenterY)) ) { 
+                        $Object->drawText($LabelX,$LabelY,$Label,array("Align"=>TEXT_ALIGN_MIDDLELEFT));                         
+                    }
+                    if ( (floor($LabelX) >  floor($CenterX)) && (floor($LabelY) >  floor($CenterY)) ) { 
+                        $Object->drawText($LabelX,$LabelY,$Label,array("Align"=>TEXT_ALIGN_TOPLEFT));                         
+                    }
+                    if ( (floor($LabelX) <  floor($CenterX)) && (floor($LabelY) <  floor($CenterY)) ) { 
+                        $Object->drawText($LabelX,$LabelY,$Label,array("Align"=>TEXT_ALIGN_BOTTOMRIGHT));                         
+                    }
+                    if ( (floor($LabelX) <  floor($CenterX)) && (floor($LabelY) == floor($CenterY)) ) { 
+                        $Object->drawText($LabelX,$LabelY,$Label,array("Align"=>TEXT_ALIGN_MIDDLERIGHT));                         
+                    }
+                    if ( (floor($LabelX) <  floor($CenterX)) && (floor($LabelY) >  floor($CenterY)) ) { 
+                        $Object->drawText($LabelX,$LabelY,$Label,array("Align"=>TEXT_ALIGN_TOPRIGHT));                         
+                    }
+                    if ( (floor($LabelX) == floor($CenterX)) && (floor($LabelY) >  floor($CenterY)) ) { 
+                        $Object->drawText($LabelX,$LabelY,$Label,array("Align"=>TEXT_ALIGN_TOPMIDDLE));                         
+                    }
+                }
+            }
+            $ID++;
+        }
+
+        /* Compute the plots position */
+        $ID = 0; $Plot = "";
+        foreach($Data["Series"] as $SerieName => $DataSet) {
+            if ( $SerieName != $LabelSerie ) {
+                $Color = array(
+                    "R"=>$Palette[$ID]["R"],
+                    "G"=>$Palette[$ID]["G"],
+                    "B"=>$Palette[$ID]["B"],
+                    "Alpha"=>$Palette[$ID]["Alpha"],
+                    "Surrounding"=>$PointSurrounding
+                );
+                foreach($DataSet["Data"] as $Key => $Value) {
+                    $Angle  = $Data["Series"][$LabelSerie]["Data"][$Key];
+                    $Length = ($EdgeHeight/($Segments*$SegmentHeight))*$Value;
+
+                    $X = cos(deg2rad($Angle+$AxisRotation)) * $Length  + $CenterX;
+                    $Y = sin(deg2rad($Angle+$AxisRotation)) * $Length  + $CenterY;
+
+                    if ( $RecordImageMap ) { 
+                        $this->pChartObject->addToImageMap(
+                            "CIRCLE",floor($X).",".floor($Y).",".floor($PointRadius),
+                            $this->pChartObject->toHTMLColor(
+                                $Palette[$ID]["R"],
+                                $Palette[$ID]["G"],
+                                $Palette[$ID]["B"]
+                            ),
+                            $DataSet["Description"],
+                            $Data["Series"][$LabelSerie]["Data"][$Key]."&deg = ".$Value
+                        );                         
+                    }
+
+                    $Plot[$ID][] = array($X,$Y,$Value);
+                }
+                $ID++;
+            }
+        }
+
+        /* Draw all that stuff! */
+        foreach($Plot as $ID => $Points) {
+            $Color = array(
+                "R"=>$Palette[$ID]["R"],
+                "G"=>$Palette[$ID]["G"],
+                "B"=>$Palette[$ID]["B"],
+                "Alpha"=>$Palette[$ID]["Alpha"],
+                "Surrounding"=>$PointSurrounding
+            );
+
+            /* Draw the polygons */
+            if ( $DrawPoly ) {
+                if ($PolyAlpha != null) {
+                    $Color = array(
+                        "R"=>$Palette[$ID]["R"],
+                        "G"=>$Palette[$ID]["G"],
+                        "B"=>$Palette[$ID]["B"],
+                        "Alpha"=>$PolyAlpha,
+                        "Surrounding"=>$PointSurrounding
+                    );
+                }
+                $PointsArray = "";
+                for ($i=0; $i<count($Points);$i++) { 
+                    $PointsArray[] = $Points[$i][0];
+                    $PointsArray[] = $Points[$i][1];                     
+                }
+
+                $Object->drawPolygon($PointsArray,$Color);
+            }
+
+            $Color = array(
+                "R"=>$Palette[$ID]["R"],
+                "G"=>$Palette[$ID]["G"],
+                "B"=>$Palette[$ID]["B"],
+                "Alpha"=>$Palette[$ID]["Alpha"],
+                "Surrounding"=>$PointSurrounding
+            );
+
+            /* Bubble and labels settings */
+            $TextSettings = array(
+                "Align"=>TEXT_ALIGN_MIDDLEMIDDLE,
+                "FontName"=>$ValueFontName,
+                "FontSize"=>$ValueFontSize,
+                "R"=>$Palette[$ID]["R"],
+                "G"=>$Palette[$ID]["G"],
+                "B"=>$Palette[$ID]["B"]
+            );
+            $InnerColor = array(
+                "R"=>$InnerBubbleR,
+                "G"=>$InnerBubbleG,
+                "B"=>$InnerBubbleB,
+                "Alpha"=>$InnerBubbleAlpha
+            );
+            if ( $OuterBubbleR != VOID ) {
+                $OuterColor = array(
+                    "R"=>$OuterBubbleR,
+                    "G"=>$OuterBubbleG,
+                    "B"=>$OuterBubbleB,
+                    "Alpha"=>$OuterBubbleAlpha
+                );
+            } else {
+                $OuterColor = array(
+                    "R"=>$Palette[$ID]["R"]+20,
+                    "G"=>$Palette[$ID]["G"]+20,
+                    "B"=>$Palette[$ID]["B"]+20,
+                    "Alpha"=>$Palette[$ID]["Alpha"]
+                );
+            }
+            /* Loop to the starting points if asked */
+            if ( $LineLoopStart && $DrawLines ) {
+                $Object->drawLine(
+                    $Points[count($Points)-1][0],
+                    $Points[count($Points)-1][1],
+                    $Points[0][0],
+                    $Points[0][1],
+                    $Color
+                );
+            }
+            /* Draw the lines & points */
+            for ($i=0; $i<count($Points);$i++) {
+                if ( $DrawLines && $i < count($Points)-1) {
+                    $Object->drawLine(
+                        $Points[$i][0],
+                        $Points[$i][1],
+                        $Points[$i+1][0],
+                        $Points[$i+1][1],
+                        $Color
+                    );
+                }
+                if ( $DrawPoints ) {
+                    $Object->drawFilledCircle(
+                        $Points[$i][0],
+                        $Points[$i][1],
+                        $PointRadius,
+                        $Color
+                    );
+                }
+                if ( $WriteValuesInBubble && $WriteValues ) {
+                    $TxtPos = $this->pChartObject->getTextBox(
+                        $Points[$i][0],
+                        $Points[$i][1],
+                        $ValueFontName,
+                        $ValueFontSize,
+                        0,
+                        $Points[$i][2]
+                    );
+                    $Radius = floor(($TxtPos[1]["X"] - $TxtPos[0]["X"] + $ValuePadding*2)/2);
+
+                    $this->pChartObject->drawFilledCircle($Points[$i][0],$Points[$i][1],$Radius+$OuterBubbleRadius,$OuterColor);
+                    $this->pChartObject->drawFilledCircle($Points[$i][0],$Points[$i][1],$Radius,$InnerColor);
+                }
+
+                if ( $WriteValues ) {
+                    $this->pChartObject->drawText($Points[$i][0]-1,$Points[$i][1]-1,$Points[$i][2],$TextSettings);
+                }
+            }
+        }
+    }
+}

vendor/szymach/c-pchart/src/Classes/pSplit.php

@@ -0,0 +1,143 @@
+<?php
+namespace CpChart\Classes;
+/*
+    pSplit - class to draw spline splitted charts
+
+    Version     : 2.1.4
+    Made by     : Jean-Damien POGOLOTTI
+    Last Update : 19/01/2014
+
+    This file can be distributed under the license you can find at :
+
+                      http://www.pchart.net/license
+
+    You can find the whole class documentation on the pChart web site.
+*/
+class pSplit
+{
+    public $pChartObject;
+
+    /**
+     * Create the encoded string
+     * @param type $Object
+     * @param type $Values
+     * @param type $Format
+     */
+    public function drawSplitPath($Object,$Values,$Format="")
+    {
+        $this->pChartObject = $Object;
+
+        $Spacing	= isset($Format["Spacing"]) ? $Format["Spacing"] : 20;
+        $TextPadding	= isset($Format["TextPadding"]) ? $Format["TextPadding"] : 2;
+        $TextPos	= isset($Format["TextPos"]) ? $Format["TextPos"] : TEXT_POS_TOP;
+        $Surrounding    = isset($Format["Surrounding"]) ? $Format["Surrounding"] : null;
+        $Force		= isset($Format["Force"]) ? $Format["Force"] : 70;
+        $Segments	= isset($Format["Segments"]) ? $Format["Segments"] : 15;
+        $FontSize	= $Object->FontSize;
+        $X1		= $Object->GraphAreaX1;
+        $Y1		= $Object->GraphAreaY1;
+        $X2		= $Object->GraphAreaX2;
+        $Y2		= $Object->GraphAreaY2;
+
+        /* Data Processing */
+        $Data    = $Values->getData();
+        $Palette = $Values->getPalette();
+
+        $LabelSerie = $Data["Abscissa"];
+        $DataSerie  = "";
+
+        foreach($Data["Series"] as $SerieName => $Value) { 
+            if ( $SerieName != $LabelSerie && $DataSerie == "" ) { 
+                $DataSerie = $SerieName;                 
+            }                 
+        }
+
+        $DataSerieSum   = array_sum($Data["Series"][$DataSerie]["Data"]);
+        $DataSerieCount = count($Data["Series"][$DataSerie]["Data"]);
+
+        /* Scale Processing */
+        if ( $TextPos == TEXT_POS_RIGHT ) {
+            $YScale = (($Y2-$Y1) - (($DataSerieCount+1)*$Spacing)) / $DataSerieSum;
+        } else {
+            $YScale = (($Y2-$Y1) - ($DataSerieCount*$Spacing)) / $DataSerieSum;
+        }
+        $LeftHeight = $DataSerieSum * $YScale;
+
+        /* Re-compute graph width depending of the text mode choosen */
+        if ( $TextPos == TEXT_POS_RIGHT ) {
+            $MaxWidth = 0;
+            foreach($Data["Series"][$LabelSerie]["Data"] as $Key => $Label) {
+                $Boundardies = $Object->getTextBox(0,0,$Object->FontName,$Object->FontSize,0,$Label);
+                if ( $Boundardies[1]["X"] > $MaxWidth ) { 
+                    $MaxWidth = $Boundardies[1]["X"] + $TextPadding*2;                     
+                }
+            }
+            $X2 = $X2 - $MaxWidth;
+        }
+
+        /* Drawing */
+        $LeftY    = ((($Y2-$Y1) / 2) + $Y1) - ($LeftHeight/2);
+        $RightY   = $Y1;
+        $VectorX  = (($X2-$X1) / 2);
+
+        foreach($Data["Series"][$DataSerie]["Data"] as $Key => $Value) {
+            if ( isset($Data["Series"][$LabelSerie]["Data"][$Key]) ) {
+                $Label = $Data["Series"][$LabelSerie]["Data"][$Key];
+            } else {
+                $Label = "-";
+            }
+            $LeftY1 = $LeftY;
+            $LeftY2 = $LeftY + $Value * $YScale;
+
+            $RightY1 = $RightY + $Spacing;
+            $RightY2 = $RightY + $Spacing + $Value * $YScale;
+
+            $Settings = array(
+                "R"=>$Palette[$Key]["R"],
+                "G"=>$Palette[$Key]["G"],
+                "B"=>$Palette[$Key]["B"],
+                "Alpha"=>$Palette[$Key]["Alpha"],
+                "NoDraw"=>true,
+                "Segments"=>$Segments,
+                "Surrounding"=>$Surrounding
+            );
+
+            $PolyGon = "";
+
+            $Angle    = $Object->getAngle($X2,$RightY1,$X1,$LeftY1);
+            $VectorX1 = cos(deg2rad($Angle+90)) * $Force + ($X2-$X1)/2 + $X1;
+            $VectorY1 = sin(deg2rad($Angle+90)) * $Force + ($RightY1-$LeftY1)/2 + $LeftY1;
+            $VectorX2 = cos(deg2rad($Angle-90)) * $Force + ($X2-$X1)/2 + $X1;
+            $VectorY2 = sin(deg2rad($Angle-90)) * $Force + ($RightY1-$LeftY1)/2 + $LeftY1;
+
+            $Points = $Object->drawBezier($X1,$LeftY1,$X2,$RightY1,$VectorX1,$VectorY1,$VectorX2,$VectorY2,$Settings);
+            foreach($Points as $Key => $Pos) { 
+                $PolyGon[] = $Pos["X"]; 
+                $PolyGon[] = $Pos["Y"];                 
+            }
+
+            $Angle    = $Object->getAngle($X2,$RightY2,$X1,$LeftY2);
+            $VectorX1 = cos(deg2rad($Angle+90)) * $Force + ($X2-$X1)/2 +$X1;
+            $VectorY1 = sin(deg2rad($Angle+90)) * $Force + ($RightY2-$LeftY2)/2 + $LeftY2;
+            $VectorX2 = cos(deg2rad($Angle-90)) * $Force + ($X2-$X1)/2 +$X1;
+            $VectorY2 = sin(deg2rad($Angle-90)) * $Force + ($RightY2-$LeftY2)/2 + $LeftY2;
+
+            $Points = $Object->drawBezier($X1,$LeftY2,$X2,$RightY2,$VectorX1,$VectorY1,$VectorX2,$VectorY2,$Settings);
+            $Points = array_reverse($Points);
+            foreach($Points as $Key => $Pos) { 
+                $PolyGon[] = $Pos["X"]; 
+                $PolyGon[] = $Pos["Y"];                 
+            }
+
+            $Object->drawPolygon($PolyGon,$Settings);
+
+            if ( $TextPos == TEXT_POS_RIGHT ) {
+                $Object->drawText($X2+$TextPadding,($RightY2-$RightY1)/2+$RightY1,$Label,array("Align"=>TEXT_ALIGN_MIDDLELEFT));
+            } else {
+                $Object->drawText($X2,$RightY1-$TextPadding,$Label,array("Align"=>TEXT_ALIGN_BOTTOMRIGHT));
+            }
+            $LeftY  = $LeftY2;
+            $RightY = $RightY2;
+        }
+    }
+}

vendor/szymach/c-pchart/src/Classes/pStock.php

@@ -0,0 +1,405 @@
+<?php
+namespace CpChart\Classes;
+ /*
+     pStock - class to draw stock charts
+
+     Version     : 2.1.4
+     Made by     : Jean-Damien POGOLOTTI
+     Last Update : 19/01/2014
+
+     This file can be distributed under the license you can find at :
+
+                       http://www.pchart.net/license
+
+     You can find the whole class documentation on the pChart web site.
+ */
+class pStock
+{
+    public $pChartObject;
+    public $pDataObject;
+
+    /**
+     * Class creator
+     * @param type $pChartObject
+     * @param type $pDataObject
+     */
+    public function __construct($pChartObject, $pDataObject)
+    {
+        $this->pChartObject = $pChartObject;
+        $this->pDataObject  = $pDataObject;
+    }
+
+    /**
+     * Draw a stock chart
+     * @param type $Format
+     * @return type
+     */
+    public function drawStockChart($Format="")
+    {
+        $SerieOpen      = isset($Format["SerieOpen"]) ? $Format["SerieOpen"] : "Open";
+        $SerieClose	= isset($Format["SerieClose"]) ? $Format["SerieClose"] : "Close";
+        $SerieMin       = isset($Format["SerieMin"]) ? $Format["SerieMin"] : "Min";
+        $SerieMax       = isset($Format["SerieMax"]) ? $Format["SerieMax"] : "Max";
+        $SerieMedian	= isset($Format["SerieMedian"]) ? $Format["SerieMedian"] : null;
+        $LineWidth      = isset($Format["LineWidth"]) ? $Format["LineWidth"] : 1;
+        $LineR		= isset($Format["LineR"]) ? $Format["LineR"] : 0;
+        $LineG		= isset($Format["LineG"]) ? $Format["LineG"] : 0;
+        $LineB		= isset($Format["LineB"]) ? $Format["LineB"] : 0;
+        $LineAlpha      = isset($Format["LineAlpha"]) ? $Format["LineAlpha"] : 100;
+        $ExtremityWidth	= isset($Format["ExtremityWidth"]) ? $Format["ExtremityWidth"] : 1;
+        $ExtremityLength    = isset($Format["ExtremityLength"]) ? $Format["ExtremityLength"] : 3;
+        $ExtremityR	= isset($Format["ExtremityR"]) ? $Format["ExtremityR"] : 0;
+        $ExtremityG	= isset($Format["ExtremityG"]) ? $Format["ExtremityG"] : 0;
+        $ExtremityB	= isset($Format["ExtremityB"]) ? $Format["ExtremityB"] : 0;
+        $ExtremityAlpha	= isset($Format["ExtremityAlpha"]) ? $Format["ExtremityAlpha"] : 100;
+        $BoxWidth       = isset($Format["BoxWidth"]) ? $Format["BoxWidth"] : 8;
+        $BoxUpR		= isset($Format["BoxUpR"]) ? $Format["BoxUpR"] : 188;
+        $BoxUpG		= isset($Format["BoxUpG"]) ? $Format["BoxUpG"] : 224;
+        $BoxUpB		= isset($Format["BoxUpB"]) ? $Format["BoxUpB"] : 46;
+        $BoxUpAlpha	= isset($Format["BoxUpAlpha"]) ? $Format["BoxUpAlpha"] : 100;
+        $BoxUpSurrounding	= isset($Format["BoxUpSurrounding"]) ? $Format["BoxUpSurrounding"] : null;
+        $BoxUpBorderR	= isset($Format["BoxUpBorderR"]) ? $Format["BoxUpBorderR"] : $BoxUpR-20;
+        $BoxUpBorderG	= isset($Format["BoxUpBorderG"]) ? $Format["BoxUpBorderG"] : $BoxUpG-20;
+        $BoxUpBorderB	= isset($Format["BoxUpBorderB"]) ? $Format["BoxUpBorderB"] : $BoxUpB-20;
+        $BoxUpBorderAlpha	= isset($Format["BoxUpBorderAlpha"]) ? $Format["BoxUpBorderAlpha"] : 100;
+        $BoxDownR       = isset($Format["BoxDownR"]) ? $Format["BoxDownR"] : 224;
+        $BoxDownG       = isset($Format["BoxDownG"]) ? $Format["BoxDownG"] : 100;
+        $BoxDownB   = isset($Format["BoxDownB"]) ? $Format["BoxDownB"] : 46;
+        $BoxDownAlpha	= isset($Format["BoxDownAlpha"]) ? $Format["BoxDownAlpha"] : 100;
+        $BoxDownSurrounding= isset($Format["BoxDownSurrounding"]) ? $Format["BoxDownSurrounding"] : null;
+        $BoxDownBorderR	= isset($Format["BoxDownBorderR"]) ? $Format["BoxDownBorderR"] : $BoxDownR-20;
+        $BoxDownBorderG	= isset($Format["BoxDownBorderG"]) ? $Format["BoxDownBorderG"] : $BoxDownG-20;
+        $BoxDownBorderB	= isset($Format["BoxDownBorderB"]) ? $Format["BoxDownBorderB"] : $BoxDownB-20;
+        $BoxDownBorderAlpha= isset($Format["BoxDownBorderAlpha"]) ? $Format["BoxDownBorderAlpha"] : 100;
+        $ShadowOnBoxesOnly	= isset($Format["ShadowOnBoxesOnly"]) ? $Format["ShadowOnBoxesOnly"] : true;
+        $MedianR        = isset($Format["MedianR"]) ? $Format["MedianR"] : 255;
+        $MedianG        = isset($Format["MedianG"]) ? $Format["MedianG"] : 0;
+        $MedianB    = isset($Format["MedianB"]) ? $Format["MedianB"] : 0;
+        $MedianAlpha	= isset($Format["MedianAlpha"]) ? $Format["MedianAlpha"] : 100;
+        $RecordImageMap	= isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : false;
+        $ImageMapTitle	= isset($Format["ImageMapTitle"]) ? $Format["ImageMapTitle"] : "Stock Chart";
+
+
+        /* Data Processing */
+        $Data    = $this->pDataObject->getData();
+        $Palette = $this->pDataObject->getPalette();
+
+        if ( $BoxUpSurrounding != null ) { 
+            $BoxUpBorderR = $BoxUpR + $BoxUpSurrounding; 
+            $BoxUpBorderG = $BoxUpG + $BoxUpSurrounding; 
+            $BoxUpBorderB = $BoxUpB + $BoxUpSurrounding;
+        }
+        if ( $BoxDownSurrounding != null ) { 
+            $BoxDownBorderR = $BoxDownR + $BoxDownSurrounding; 
+            $BoxDownBorderG = $BoxDownG + $BoxDownSurrounding; 
+            $BoxDownBorderB = $BoxDownB + $BoxDownSurrounding;             
+        }
+
+        if ( $LineWidth != 1 ) { 
+            $LineOffset = $LineWidth / 2;
+        }
+        $BoxOffset = $BoxWidth / 2;
+
+        $Data = $this->pChartObject->DataSet->getData();
+        list($XMargin,$XDivs) = $this->pChartObject->scaleGetXSettings();
+
+        if (!isset($Data["Series"][$SerieOpen]) 
+            || !isset($Data["Series"][$SerieClose]) 
+            || !isset($Data["Series"][$SerieMin]) 
+            || !isset($Data["Series"][$SerieMax]) 
+        ) {
+            return(STOCK_MISSING_SERIE);
+        }
+        $Plots = "";
+        foreach($Data["Series"][$SerieOpen]["Data"] as $Key => $Value) {
+            $Point = "";
+            if (isset($Data["Series"][$SerieClose]["Data"][$Key]) 
+                || isset($Data["Series"][$SerieMin]["Data"][$Key]) 
+                || isset($Data["Series"][$SerieMax]["Data"][$Key])
+            ) {
+                $Point = array(
+                    $Value,
+                    $Data["Series"][$SerieClose]["Data"][$Key],
+                    $Data["Series"][$SerieMin]["Data"][$Key],
+                    $Data["Series"][$SerieMax]["Data"][$Key]
+                );
+            }
+            if ($SerieMedian != null && isset($Data["Series"][$SerieMedian]["Data"][$Key]) ) {
+                $Point[] = $Data["Series"][$SerieMedian]["Data"][$Key];
+            }
+            $Plots[] = $Point;
+        }
+
+        $AxisID	= $Data["Series"][$SerieOpen]["Axis"];
+        $Mode	= $Data["Axis"][$AxisID]["Display"];
+        $Format	= $Data["Axis"][$AxisID]["Format"];
+        $Unit	= $Data["Axis"][$AxisID]["Unit"];
+
+        $YZero	= $this->pChartObject->scaleComputeY(0,array("AxisID"=>$AxisID));
+        $XStep	= ($this->pChartObject->GraphAreaX2-$this->pChartObject->GraphAreaX1-$XMargin*2)/$XDivs;
+
+        $X = $this->pChartObject->GraphAreaX1 + $XMargin;
+        $Y = $this->pChartObject->GraphAreaY1 + $XMargin;
+
+        $LineSettings = array("R"=>$LineR,"G"=>$LineG,"B"=>$LineB,"Alpha"=>$LineAlpha);
+        $ExtremitySettings = array("R"=>$ExtremityR,"G"=>$ExtremityG,"B"=>$ExtremityB,"Alpha"=>$ExtremityAlpha);
+        $BoxUpSettings	= array(
+            "R"=>$BoxUpR,
+            "G"=>$BoxUpG,
+            "B"=>$BoxUpB,
+            "Alpha"=>$BoxUpAlpha,
+            "BorderR"=>$BoxUpBorderR,
+            "BorderG"=>$BoxUpBorderG,
+            "BorderB"=>$BoxUpBorderB,
+            "BorderAlpha"=>$BoxUpBorderAlpha
+        );
+        $BoxDownSettings = array(
+            "R"=>$BoxDownR,
+            "G"=>$BoxDownG,
+            "B"=>$BoxDownB,
+            "Alpha"=>$BoxDownAlpha,
+            "BorderR"=>$BoxDownBorderR,
+            "BorderG"=>$BoxDownBorderG,
+            "BorderB"=>$BoxDownBorderB,
+            "BorderAlpha"=>$BoxDownBorderAlpha
+        );
+        $MedianSettings	= array("R"=>$MedianR,"G"=>$MedianG,"B"=>$MedianB,"Alpha"=>$MedianAlpha);
+
+        foreach($Plots as $Key =>$Points) {
+            $PosArray = $this->pChartObject->scaleComputeY($Points,array("AxisID"=>$AxisID));
+
+            $Values = "Open :".$Data["Series"][$SerieOpen]["Data"][$Key]
+                    . "<BR>Close : ".$Data["Series"][$SerieClose]["Data"][$Key]
+                    . "<BR>Min : ".$Data["Series"][$SerieMin]["Data"][$Key]
+                    . "<BR>Max : ".$Data["Series"][$SerieMax]["Data"][$Key]."<BR>";
+            if ( $SerieMedian != null ) { 
+                $Values = $Values."Median : ".$Data["Series"][$SerieMedian]["Data"][$Key]."<BR>";
+            }
+            if ( $PosArray[0] > $PosArray[1] ) { 
+                $ImageMapColor = $this->pChartObject->toHTMLColor($BoxUpR,$BoxUpG,$BoxUpB);
+            } else { 
+                $ImageMapColor = $this->pChartObject->toHTMLColor($BoxDownR,$BoxDownG,$BoxDownB);
+            } 
+
+            if ( $Data["Orientation"] == SCALE_POS_LEFTRIGHT ) {
+                if ( $YZero > $this->pChartObject->GraphAreaY2-1 ) { 
+                    $YZero = $this->pChartObject->GraphAreaY2-1;                     
+                }
+                if ( $YZero < $this->pChartObject->GraphAreaY1+1 ) { 
+                    $YZero = $this->pChartObject->GraphAreaY1+1;
+                }
+
+                if ( $XDivs == 0 ) { 
+                    $XStep = 0;                     
+                } else { 
+                    $XStep = ($this->pChartObject->GraphAreaX2-$this->pChartObject->GraphAreaX1-$XMargin*2)/$XDivs;
+                }
+
+                if ( $ShadowOnBoxesOnly ) { 
+                    $RestoreShadow = $this->pChartObject->Shadow; 
+                    $this->pChartObject->Shadow = false;
+                }
+
+                if ( $LineWidth == 1 ) {
+                    $this->pChartObject->drawLine($X,$PosArray[2],$X,$PosArray[3],$LineSettings);
+                } else {
+                    $this->pChartObject->drawFilledRectangle($X-$LineOffset,$PosArray[2],$X+$LineOffset,$PosArray[3],$LineSettings);
+                }
+                
+                if ( $ExtremityWidth == 1 ) {
+                    $this->pChartObject->drawLine($X-$ExtremityLength,$PosArray[2],$X+$ExtremityLength,$PosArray[2],$ExtremitySettings);
+                    $this->pChartObject->drawLine($X-$ExtremityLength,$PosArray[3],$X+$ExtremityLength,$PosArray[3],$ExtremitySettings);
+
+                    if ( $RecordImageMap ) { 
+                        $this->pChartObject->addToImageMap(
+                            "RECT",
+                            floor($X-$ExtremityLength).",".floor($PosArray[2])
+                                .",".floor($X+$ExtremityLength).","
+                                .floor($PosArray[3]),
+                            $ImageMapColor,
+                            $ImageMapTitle,
+                            $Values
+                        );
+                    }
+                } else {
+                    $this->pChartObject->drawFilledRectangle(
+                        $X-$ExtremityLength,
+                        $PosArray[2],
+                        $X+$ExtremityLength,
+                        $PosArray[2]-$ExtremityWidth,
+                        $ExtremitySettings
+                    );
+                    $this->pChartObject->drawFilledRectangle(
+                        $X-$ExtremityLength,
+                        $PosArray[3],
+                        $X+$ExtremityLength,
+                        $PosArray[3]+$ExtremityWidth,
+                        $ExtremitySettings
+                    );
+
+                    if ( $RecordImageMap ) { 
+                        $this->pChartObject->addToImageMap(
+                            "RECT",
+                            floor($X-$ExtremityLength).",".floor($PosArray[2]-$ExtremityWidth)
+                                .",".floor($X+$ExtremityLength).","
+                                .floor($PosArray[3]+$ExtremityWidth),
+                            $ImageMapColor,
+                            $ImageMapTitle,
+                            $Values
+                        );
+                    }
+                }
+
+                if ( $ShadowOnBoxesOnly ) { 
+                    $this->pChartObject->Shadow = $RestoreShadow;
+                }
+
+                if ( $PosArray[0] > $PosArray[1] ) {
+                    $this->pChartObject->drawFilledRectangle(
+                        $X-$BoxOffset,
+                        $PosArray[0],
+                        $X+$BoxOffset,
+                        $PosArray[1],
+                        $BoxUpSettings
+                    );
+                } else {
+                    $this->pChartObject->drawFilledRectangle(
+                        $X-$BoxOffset,
+                        $PosArray[0],
+                        $X+$BoxOffset,
+                        $PosArray[1],
+                        $BoxDownSettings
+                    );
+                }
+                
+                if ( isset($PosArray[4]) ) {
+                    $this->pChartObject->drawLine(
+                        $X-$ExtremityLength,
+                        $PosArray[4],
+                        $X+$ExtremityLength,
+                        $PosArray[4],
+                        $MedianSettings
+                    );
+                }
+                $X = $X + $XStep;
+            } elseif ( $Data["Orientation"] == SCALE_POS_TOPBOTTOM ) {
+                if ( $YZero > $this->pChartObject->GraphAreaX2-1 ) { 
+                    $YZero = $this->pChartObject->GraphAreaX2-1;
+                }
+                if ( $YZero < $this->pChartObject->GraphAreaX1+1 ) {
+                    $YZero = $this->pChartObject->GraphAreaX1+1;
+                }
+
+                if ( $XDivs == 0 ) { 
+                    $XStep = 0;                     
+                } else {
+                    $XStep = ($this->pChartObject->GraphAreaY2-$this->pChartObject->GraphAreaY1-$XMargin*2)/$XDivs;
+                }
+
+                if ( $LineWidth == 1 ) {
+                    $this->pChartObject->drawLine($PosArray[2],$Y,$PosArray[3],$Y,$LineSettings);
+                } else {
+                    $this->pChartObject->drawFilledRectangle(
+                        $PosArray[2],
+                        $Y-$LineOffset,
+                        $PosArray[3],
+                        $Y+$LineOffset,
+                        $LineSettings
+                    );
+                }
+                if ( $ShadowOnBoxesOnly ) { 
+                    $RestoreShadow = $this->pChartObject->Shadow; 
+                    $this->pChartObject->Shadow = false;
+                }
+
+                if ( $ExtremityWidth == 1 ) {
+                    $this->pChartObject->drawLine(
+                        $PosArray[2],
+                        $Y-$ExtremityLength,
+                        $PosArray[2],
+                        $Y+$ExtremityLength,
+                        $ExtremitySettings
+                    );
+                    $this->pChartObject->drawLine(
+                        $PosArray[3],
+                        $Y-$ExtremityLength,
+                        $PosArray[3],
+                        $Y+$ExtremityLength,
+                        $ExtremitySettings
+                    );
+
+                    if ( $RecordImageMap ) { 
+                        $this->pChartObject->addToImageMap(
+                            "RECT",
+                            floor($PosArray[2]).",".floor($Y-$ExtremityLength)
+                            .",".floor($PosArray[3]).",".floor($Y+$ExtremityLength),
+                            $ImageMapColor,
+                            $ImageMapTitle,
+                            $Values
+                        );
+                    }
+                } else {
+                    $this->pChartObject->drawFilledRectangle(
+                        $PosArray[2],
+                        $Y-$ExtremityLength,
+                        $PosArray[2]-$ExtremityWidth,
+                        $Y+$ExtremityLength,
+                        $ExtremitySettings
+                    );
+                    $this->pChartObject->drawFilledRectangle(
+                        $PosArray[3],
+                        $Y-$ExtremityLength,
+                        $PosArray[3]+$ExtremityWidth,
+                        $Y+$ExtremityLength,
+                        $ExtremitySettings
+                    );
+
+                    if ( $RecordImageMap ) { 
+                        $this->pChartObject->addToImageMap(
+                            "RECT",
+                            floor($PosArray[2]-$ExtremityWidth).","
+                            .floor($Y-$ExtremityLength).","
+                            .floor($PosArray[3]+$ExtremityWidth).","
+                            .floor($Y+$ExtremityLength),
+                            $ImageMapColor,
+                            $ImageMapTitle,
+                            $Values
+                        );
+                    }
+                }
+
+                if ( $ShadowOnBoxesOnly ) { 
+                    $this->pChartObject->Shadow = $RestoreShadow;
+                }
+
+                if ( $PosArray[0] < $PosArray[1] ) {
+                    $this->pChartObject->drawFilledRectangle(
+                        $PosArray[0],
+                        $Y-$BoxOffset,
+                        $PosArray[1],
+                        $Y+$BoxOffset,
+                        $BoxUpSettings
+                    );
+                } else {
+                    $this->pChartObject->drawFilledRectangle(
+                        $PosArray[0],
+                        $Y-$BoxOffset,
+                        $PosArray[1],
+                        $Y+$BoxOffset,
+                        $BoxDownSettings
+                    );
+                }
+                if ( isset($PosArray[4]) ) {
+                    $this->pChartObject->drawLine(
+                        $PosArray[4],
+                        $Y-$ExtremityLength,
+                        $PosArray[4],
+                        $Y+$ExtremityLength,
+                        $MedianSettings
+                    );
+                }
+                $Y = $Y + $XStep;
+            }
+        }
+    }
+}

vendor/szymach/c-pchart/src/Classes/pSurface.php

@@ -0,0 +1,392 @@
+<?php
+namespace CpChart\Classes;
+/*
+    pSurface - class to draw surface charts
+
+    Version     : 2.1.4
+    Made by     : Jean-Damien POGOLOTTI
+    Last Update : 19/01/2014
+
+    This file can be distributed under the license you can find at :
+
+                      http://www.pchart.net/license
+
+    You can find the whole class documentation on the pChart web site.
+*/
+class pSurface
+{
+    public $pChartObject;
+    public $GridSizeX;
+    public $GridSizeY;
+    public $Points;
+
+    /**
+     * Class creator
+     * @param type $pChartObject
+     * @param type $pDataObject - added for compatibility with other classes
+     */
+    public function __construct($pChartObject, $pDataObject = null)
+    {
+        $this->pChartObject = $pChartObject;
+        $this->GridSize     = 10;
+        $this->Points       = "";
+    }
+
+    /**
+     * Define the grid size and initialise the 2D matrix
+     * @param type $XSize
+     * @param type $YSize
+     */
+    public function setGrid($XSize=10,$YSize=10)
+    {
+        for ($X=0; $X<=$XSize; $X++) { 
+            for ($Y=0; $Y<=$YSize; $Y++) { 
+                $this->Points[$X][$Y]=UNKNOWN;                 
+            }
+        } 
+
+        $this->GridSizeX = $XSize;
+        $this->GridSizeY = $YSize;
+    }
+
+    /**
+     * Add a point on the grid
+     * @param type $X
+     * @param type $Y
+     * @param type $Value
+     * @param type $Force
+     * @return type
+     */
+    public function addPoint($X,$Y,$Value,$Force=TRUE)
+    {
+        if ( $X < 0 || $X >$this->GridSizeX ) { 
+            return(0);           
+        }
+        if ( $Y < 0 || $Y >$this->GridSizeY ) { 
+            return(0);
+        }
+
+        if ( $this->Points[$X][$Y] == UNKNOWN || $Force ) {
+            $this->Points[$X][$Y] = $Value;
+        } elseif ( $this->Points[$X][$Y] == UNKNOWN ) {
+            $this->Points[$X][$Y] = $Value;
+        } else {
+            $this->Points[$X][$Y] = ($this->Points[$X][$Y] + $Value)/2;
+        }
+    }
+
+   /**
+    * Write the X labels 
+    * @param type $Format
+    * @return type
+    */
+   public function writeXLabels($Format="")
+   {
+        $R		= isset($Format["R"]) ? $Format["R"] : $this->pChartObject->FontColorR;
+        $G		= isset($Format["G"]) ? $Format["G"] : $this->pChartObject->FontColorG;
+        $B		= isset($Format["B"]) ? $Format["B"] : $this->pChartObject->FontColorB;
+        $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : $this->pChartObject->FontColorA;
+        $Angle		= isset($Format["Angle"]) ? $Format["Angle"] : 0;
+        $Padding	= isset($Format["Padding"]) ? $Format["Padding"] : 5;
+        $Position	= isset($Format["Position"]) ? $Format["Position"] : LABEL_POSITION_TOP;
+        $Labels		= isset($Format["Labels"]) ? $Format["Labels"] : null;
+        $CountOffset	= isset($Format["CountOffset"]) ? $Format["CountOffset"] : 0;
+
+        if ( $Labels != null && !is_array($Labels) ) { 
+            $Label = $Labels; 
+            $Labels = ""; 
+            $Labels[] = $Label;             
+        }
+
+        $X0    = $this->pChartObject->GraphAreaX1;
+        $XSize = ($this->pChartObject->GraphAreaX2 - $this->pChartObject->GraphAreaX1) / ($this->GridSizeX+1);
+
+        $Settings = array("Angle"=>$Angle,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha);
+        if ( $Position == LABEL_POSITION_TOP ) {
+            $YPos  = $this->pChartObject->GraphAreaY1 - $Padding;
+            if ($Angle == 0 ) { $Settings["Align"] = TEXT_ALIGN_BOTTOMMIDDLE; }
+            if ($Angle != 0 ) { $Settings["Align"] = TEXT_ALIGN_MIDDLELEFT; }
+        } elseif ( $Position == LABEL_POSITION_BOTTOM ) {
+            $YPos  = $this->pChartObject->GraphAreaY2 + $Padding;
+            if ($Angle == 0 ) { $Settings["Align"] = TEXT_ALIGN_TOPMIDDLE; }
+            if ($Angle != 0 ) { $Settings["Align"] = TEXT_ALIGN_MIDDLERIGHT; }
+        } else {
+            return(-1);
+        }
+        for ($X=0;$X<=$this->GridSizeX;$X++) {
+            $XPos = floor($X0+$X*$XSize + $XSize/2);
+
+            if( $Labels == null || !isset($Labels[$X]) ) {
+                $Value = $X+$CountOffset;
+            } else {
+                $Value = $Labels[$X];
+            }
+            $this->pChartObject->drawText($XPos,$YPos,$Value,$Settings);
+        }
+    }
+
+   /**
+    * Write the Y labels
+    * @param type $Format
+    * @return type
+    */
+   public function writeYLabels($Format="")
+   {
+        $R		= isset($Format["R"]) ? $Format["R"] : $this->pChartObject->FontColorR;
+        $G		= isset($Format["G"]) ? $Format["G"] : $this->pChartObject->FontColorG;
+        $B		= isset($Format["B"]) ? $Format["B"] : $this->pChartObject->FontColorB;
+        $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : $this->pChartObject->FontColorA;
+        $Angle		= isset($Format["Angle"]) ? $Format["Angle"] : 0;
+        $Padding	= isset($Format["Padding"]) ? $Format["Padding"] : 5;
+        $Position	= isset($Format["Position"]) ? $Format["Position"] : LABEL_POSITION_LEFT;
+        $Labels		= isset($Format["Labels"]) ? $Format["Labels"] : null;
+        $CountOffset	= isset($Format["CountOffset"]) ? $Format["CountOffset"] : 0;
+
+        if ( $Labels != null && !is_array($Labels) ) { 
+            $Label = $Labels; $Labels = ""; 
+            $Labels[] = $Label;
+        }
+
+        $Y0    = $this->pChartObject->GraphAreaY1;
+        $YSize = ($this->pChartObject->GraphAreaY2 - $this->pChartObject->GraphAreaY1) / ($this->GridSizeY+1);
+
+        $Settings = array("Angle"=>$Angle,"R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha);
+        if ( $Position == LABEL_POSITION_LEFT ) { 
+            $XPos  = $this->pChartObject->GraphAreaX1 - $Padding; 
+            $Settings["Align"] = TEXT_ALIGN_MIDDLERIGHT;
+        } elseif ( $Position == LABEL_POSITION_RIGHT ) { 
+            $XPos  = $this->pChartObject->GraphAreaX2 + $Padding; 
+            $Settings["Align"] = TEXT_ALIGN_MIDDLELEFT;             
+        } else {
+            return(-1);
+        }
+        for ($Y=0;$Y<=$this->GridSizeY;$Y++) {
+            $YPos = floor($Y0+$Y*$YSize + $YSize/2);
+
+            if( $Labels == null || !isset($Labels[$Y]) ) {
+                $Value = $Y+$CountOffset;
+            } else {
+                $Value = $Labels[$Y];
+            }
+            $this->pChartObject->drawText($XPos,$YPos,$Value,$Settings);
+        }
+    }
+
+    /**
+     * Draw the area arround the specified Threshold
+     * @param type $Threshold
+     * @param type $Format
+     */
+    public function drawContour($Threshold,$Format="")
+    {
+        $R          = isset($Format["R"]) ? $Format["R"] : 0;
+        $G          = isset($Format["G"]) ? $Format["G"] : 0;
+        $B          = isset($Format["B"]) ? $Format["B"] : 0;
+        $Alpha      = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
+        $Ticks      = isset($Format["Ticks"]) ? $Format["Ticks"] : 3;
+        $Padding    = isset($Format["Padding"]) ? $Format["Padding"] : 0;
+
+        $X0    = $this->pChartObject->GraphAreaX1;
+        $Y0    = $this->pChartObject->GraphAreaY1;
+        $XSize = ($this->pChartObject->GraphAreaX2 - $this->pChartObject->GraphAreaX1) / ($this->GridSizeX+1);
+        $YSize = ($this->pChartObject->GraphAreaY2 - $this->pChartObject->GraphAreaY1) / ($this->GridSizeY+1);
+
+        $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks);
+
+        for ($X=0;$X<=$this->GridSizeX;$X++) {
+            for ($Y=0;$Y<=$this->GridSizeY;$Y++) {
+                $Value = $this->Points[$X][$Y];
+
+                if ( $Value != UNKNOWN && $Value != IGNORED && $Value >= $Threshold) {
+                    $X1 = floor($X0+$X*$XSize)+$Padding;
+                    $Y1 = floor($Y0+$Y*$YSize)+$Padding;
+                    $X2 = floor($X0+$X*$XSize+$XSize);
+                    $Y2 = floor($Y0+$Y*$YSize+$YSize);
+
+                    if ($X > 0 
+                        && $this->Points[$X-1][$Y] != UNKNOWN 
+                        && $this->Points[$X-1][$Y] != IGNORED 
+                        && $this->Points[$X-1][$Y] < $Threshold
+                    ) {
+                        $this->pChartObject->drawLine($X1,$Y1,$X1,$Y2,$Color);
+                    }
+                    if ($Y > 0 
+                        && $this->Points[$X][$Y-1] != UNKNOWN 
+                        && $this->Points[$X][$Y-1] != IGNORED 
+                        && $this->Points[$X][$Y-1] < $Threshold
+                    ) {
+                        $this->pChartObject->drawLine($X1,$Y1,$X2,$Y1,$Color);
+                    }
+                    if ($X < $this->GridSizeX 
+                        && $this->Points[$X+1][$Y] != UNKNOWN 
+                        && $this->Points[$X+1][$Y] != IGNORED 
+                        && $this->Points[$X+1][$Y] < $Threshold
+                    ) {
+                        $this->pChartObject->drawLine($X2,$Y1,$X2,$Y2,$Color);
+                    }
+                    if ($Y < $this->GridSizeY 
+                        && $this->Points[$X][$Y+1] != UNKNOWN 
+                        && $this->Points[$X][$Y+1] != IGNORED 
+                        && $this->Points[$X][$Y+1] < $Threshold
+                    ) {
+                        $this->pChartObject->drawLine($X1,$Y2,$X2,$Y2,$Color);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Draw the surface chart
+     * @param type $Format
+     */
+    public function drawSurface($Format="")
+    {
+        $Palette	= isset($Format["Palette"]) ? $Format["Palette"] : null;
+        $ShadeR1	= isset($Format["ShadeR1"]) ? $Format["ShadeR1"] : 77;
+        $ShadeG1	= isset($Format["ShadeG1"]) ? $Format["ShadeG1"] : 205;
+        $ShadeB1	= isset($Format["ShadeB1"]) ? $Format["ShadeB1"] : 21;
+        $ShadeA1	= isset($Format["ShadeA1"]) ? $Format["ShadeA1"] : 40;
+        $ShadeR2	= isset($Format["ShadeR2"]) ? $Format["ShadeR2"] : 227;
+        $ShadeG2	= isset($Format["ShadeG2"]) ? $Format["ShadeG2"] : 135;
+        $ShadeB2	= isset($Format["ShadeB2"]) ? $Format["ShadeB2"] : 61;
+        $ShadeA2	= isset($Format["ShadeA2"]) ? $Format["ShadeA2"] : 100;
+        $Border		= isset($Format["Border"]) ? $Format["Border"] : false;
+        $BorderR	= isset($Format["BorderR"]) ? $Format["BorderR"] : 0;
+        $BorderG	= isset($Format["BorderG"]) ? $Format["BorderG"] : 0;
+        $BorderB	= isset($Format["BorderB"]) ? $Format["BorderB"] : 0;
+        $Surrounding	= isset($Format["Surrounding"]) ? $Format["Surrounding"] : -1;
+        $Padding	= isset($Format["Padding"]) ? $Format["Padding"] : 1;
+
+        $X0    = $this->pChartObject->GraphAreaX1;
+        $Y0    = $this->pChartObject->GraphAreaY1;
+        $XSize = ($this->pChartObject->GraphAreaX2 - $this->pChartObject->GraphAreaX1) / ($this->GridSizeX+1);
+        $YSize = ($this->pChartObject->GraphAreaY2 - $this->pChartObject->GraphAreaY1) / ($this->GridSizeY+1);
+
+        for($X=0;$X<=$this->GridSizeX;$X++) {
+            for($Y=0;$Y<=$this->GridSizeY;$Y++) {
+                $Value = $this->Points[$X][$Y];
+
+                if ( $Value != UNKNOWN && $Value != IGNORED ) {
+                    $X1 = floor($X0+$X*$XSize)+$Padding;
+                    $Y1 = floor($Y0+$Y*$YSize)+$Padding;
+                    $X2 = floor($X0+$X*$XSize+$XSize);
+                    $Y2 = floor($Y0+$Y*$YSize+$YSize);
+
+                    if ( $Palette != null ) {
+                        if ( isset($Palette[$Value]) && isset($Palette[$Value]["R"]) ) { 
+                            $R = $Palette[$Value]["R"];
+                        } else { 
+                            $R = 0;                        
+                        }
+                        
+                        if ( isset($Palette[$Value]) && isset($Palette[$Value]["G"]) ) { 
+                            $G = $Palette[$Value]["G"];                             
+                        } else { 
+                            $G = 0;
+                        }
+                        
+                        if ( isset($Palette[$Value]) && isset($Palette[$Value]["B"]) ) { 
+                            $B = $Palette[$Value]["B"];                             
+                        } else { 
+                            $B = 0;
+                        }
+                        if ( isset($Palette[$Value]) && isset($Palette[$Value]["Alpha"]) ) { 
+                            $Alpha = $Palette[$Value]["Alpha"];                             
+                        } else { 
+                            $Alpha = 1000;                             
+                        }
+                    } else {
+                        $R = (($ShadeR2-$ShadeR1)/100)*$Value + $ShadeR1;
+                        $G = (($ShadeG2-$ShadeG1)/100)*$Value + $ShadeG1;
+                        $B = (($ShadeB2-$ShadeB1)/100)*$Value + $ShadeB1;
+                        $Alpha = (($ShadeA2-$ShadeA1)/100)*$Value + $ShadeA1;
+                    }
+
+                    $Settings = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha);
+                    if ( $Border ) { 
+                        $Settings["BorderR"] = $BorderR;
+                        $Settings["BorderG"] = $BorderG;
+                        $Settings["BorderB"] = $BorderB;                         
+                    }
+                    if ( $Surrounding != -1 ) { 
+                        $Settings["BorderR"] = $R+$Surrounding; 
+                        $Settings["BorderG"] = $G+$Surrounding;
+                        $Settings["BorderB"] = $B+$Surrounding;
+                    }
+
+                    $this->pChartObject->drawFilledRectangle($X1,$Y1,$X2-1,$Y2-1,$Settings);
+                }
+            }
+        }
+    }
+
+    /**
+     * Compute the missing points
+     */
+    public function computeMissing()
+    {
+        $Missing = "";
+        for ($X=0;$X<=$this->GridSizeX;$X++) {
+            for ($Y=0;$Y<=$this->GridSizeY;$Y++) {
+                if ( $this->Points[$X][$Y] == UNKNOWN ) {
+                    $Missing[] = $X.",".$Y;
+                }
+            }
+        }
+        shuffle($Missing);
+
+        foreach($Missing as $Key => $Pos) {
+            $Pos = preg_split("/,/",$Pos);
+            $X   = $Pos[0];
+            $Y   = $Pos[1];
+
+            if ( $this->Points[$X][$Y] == UNKNOWN ) {
+                $NearestNeighbor = $this->getNearestNeighbor($X,$Y);
+
+                $Value = 0; $Points = 0;
+                for ($Xi=$X-$NearestNeighbor;$Xi<=$X+$NearestNeighbor;$Xi++) {
+                    for ($Yi=$Y-$NearestNeighbor;$Yi<=$Y+$NearestNeighbor;$Yi++) {
+                        if ($Xi >=0 
+                            && $Yi >= 0 
+                            && $Xi <= $this->GridSizeX 
+                            && $Yi <= $this->GridSizeY 
+                            && $this->Points[$Xi][$Yi] != UNKNOWN 
+                            && $this->Points[$Xi][$Yi] != IGNORED
+                        ) {
+                            $Value = $Value + $this->Points[$Xi][$Yi]; $Points++;
+                        }
+                    }
+                }
+
+                if ( $Points != 0 ) { 
+                    $this->Points[$X][$Y] = $Value / $Points;                   
+                }
+            }
+        }
+    }
+
+    /**
+     * Return the nearest Neighbor distance of a point
+     * @param type $Xp
+     * @param type $Yp
+     * @return type
+     */
+    public function getNearestNeighbor($Xp,$Yp)
+    {
+        $Nearest = UNKNOWN;
+        for ($X=0;$X<=$this->GridSizeX;$X++) {
+            for ($Y=0;$Y<=$this->GridSizeY;$Y++) {
+                if ( $this->Points[$X][$Y] != UNKNOWN && $this->Points[$X][$Y] != IGNORED ) {
+                    $DistanceX = max($Xp,$X)-min($Xp,$X);
+                    $DistanceY = max($Yp,$Y)-min($Yp,$Y);
+                    $Distance  = max($DistanceX,$DistanceY);
+                    if ( $Distance < $Nearest || $Nearest == UNKNOWN ) { 
+                        $Nearest = $Distance;
+                    }
+                }
+            }
+        }
+        return($Nearest);
+    }
+}

vendor/szymach/c-pchart/src/Resources/data/128B.db

@@ -0,0 +1,107 @@
+0;32;11011001100
+1;33;11001101100
+2;34;11001100110
+3;35;10010011000
+4;36;10010001100
+5;37;10001001100
+6;38;10011001000
+7;39;10011000100
+8;40;10001100100
+9;41;11001001000
+10;42;11001000100
+11;43;11000100100
+12;44;10110011100
+13;45;10011011100
+14;46;10011001110
+15;47;10111001100
+16;48;10011101100
+17;49;10011100110
+18;50;11001110010
+19;51;11001011100
+20;52;11001001110
+21;53;11011100100
+22;54;11001110100
+23;55;11101101110
+24;56;11101001100
+25;57;11100101100
+26;58;11100100110
+27;59;11101100100
+28;60;11100110100
+29;61;11100110010
+30;62;11011011000
+31;63;11011000110
+32;64;11000110110
+33;65;10100011000
+34;66;10001011000
+35;67;10001000110
+36;68;10110001000
+37;69;10001101000
+38;70;10001100010
+39;71;11010001000
+40;72;11000101000
+41;73;11000100010
+42;74;10110111000
+43;75;10110001110
+44;76;10001101110
+45;77;10111011000
+46;78;10111000110
+47;79;10001110110
+48;80;11101110110
+49;81;11010001110
+50;82;11000101110
+51;83;11011101000
+52;84;11011100010
+53;85;11011101110
+54;86;11101011000
+55;87;11101000110
+56;88;11100010110
+57;89;11101101000
+58;90;11101100010
+59;91;11100011010
+60;92;11101111010
+61;93;11001000010
+62;94;11110001010
+63;95;10100110000
+64;96;10100001100
+65;97;10010110000
+66;98;10010000110
+67;99;10000101100
+68;100;10000100110
+69;101;10110010000
+70;102;10110000100
+71;103;10011010000
+72;104;10011000010
+73;105;10000110100
+74;106;10000110010
+75;107;11000010010
+76;108;11001010000
+77;109;11110111010
+78;110;11000010100
+79;111;10001111010
+80;112;10100111100
+81;113;10010111100
+82;114;10010011110
+83;115;10111100100
+84;116;10011110100
+85;117;10011110010
+86;118;11110100100
+87;119;11110010100
+88;120;11110010010
+89;121;11011011110
+90;122;11011110110
+91;123;11110110110
+92;124;10101111000
+93;125;10100011110
+94;126;10001011110
+95;200;10111101000
+96;201;10111100010
+97;202;11110101000
+98;203;11110100010
+99;204;10111011110
+100;205;10111101110
+101;206;11101011110
+102;207;11110101110
+103;208;11010000100
+104;209;11010010000
+105;210;11010011100
+106;211;1100011101011

vendor/szymach/c-pchart/src/Resources/data/39.db

@@ -0,0 +1,44 @@
+0;101001101101
+1;110100101011
+2;101100101011
+3;110110010101
+4;101001101011
+5;110100110101
+6;101100110101
+7;101001011011
+8;110100101101
+9;101100101101
+A;110101001011
+B;101101001011
+C;110110100101
+D;101011001011
+E;110101100101
+F;101101100101
+G;101010011011
+H;110101001101
+I;101101001101
+J;101011001101
+K;110101010011
+L;101101010011
+M;110110101001
+N;101011010011
+O;110101101001
+P;101101101001
+Q;101010110011
+R;110101011001
+S;101101011001
+T;101011011001
+U;110010101011
+V;100110101011
+W;110011010101
+X;100101101011
+Y;110010110101
+Z;100110110101
+-;100101011011
+.;110010101101
+ ;100110101101
+$;100100100101
+/;100100101001
++;100101001001
+%;101001001001
+*;100101101101

vendor/szymach/c-pchart/src/Resources/data/constants.php

@@ -0,0 +1,208 @@
+<?php
+
+/**
+ * @filesource src/Resources/data/configuration.php
+ * 
+ * All the class constants moved into a single file for compatibility
+ * with the factory service class. This file is *required* for the library
+ * to function.
+ */
+/**
+ * pBubble
+ */
+define("BUBBLE_SHAPE_ROUND", 700001);
+define("BUBBLE_SHAPE_SQUARE", 700002);
+
+/**
+ * pData
+ */
+/* Axis configuration */
+define("AXIS_FORMAT_DEFAULT", 680001);
+define("AXIS_FORMAT_TIME", 680002);
+define("AXIS_FORMAT_DATE", 680003);
+define("AXIS_FORMAT_METRIC", 680004);
+define("AXIS_FORMAT_CURRENCY", 680005);
+define("AXIS_FORMAT_TRAFFIC", 680006);
+define("AXIS_FORMAT_CUSTOM", 680007);
+/* Axis position */
+define("AXIS_POSITION_LEFT", 681001);
+define("AXIS_POSITION_RIGHT", 681002);
+define("AXIS_POSITION_TOP", 681001);
+define("AXIS_POSITION_BOTTOM", 681002);
+/* Families of data points */
+define("SERIE_SHAPE_FILLEDCIRCLE", 681011);
+define("SERIE_SHAPE_FILLEDTRIANGLE", 681012);
+define("SERIE_SHAPE_FILLEDSQUARE", 681013);
+define("SERIE_SHAPE_FILLEDDIAMOND", 681017);
+define("SERIE_SHAPE_CIRCLE", 681014);
+define("SERIE_SHAPE_TRIANGLE", 681015);
+define("SERIE_SHAPE_SQUARE", 681016);
+define("SERIE_SHAPE_DIAMOND", 681018);
+/* Axis position */
+define("AXIS_X", 682001);
+define("AXIS_Y", 682002);
+/* Define value limits */
+define("ABSOLUTE_MIN", -10000000000000);
+define("ABSOLUTE_MAX", 10000000000000);
+/* Replacement to the PHP null keyword */
+define("VOID", 0.123456789);
+/* Euro symbol for GD fonts */
+define("EURO_SYMBOL", utf8_encode("&#8364;"));
+
+/**
+ * pDraw
+ */
+define("DIRECTION_VERTICAL", 690001);
+define("DIRECTION_HORIZONTAL", 690002);
+define("SCALE_POS_LEFTRIGHT", 690101);
+define("SCALE_POS_TOPBOTTOM", 690102);
+define("SCALE_MODE_FLOATING", 690201);
+define("SCALE_MODE_START0", 690202);
+define("SCALE_MODE_ADDALL", 690203);
+define("SCALE_MODE_ADDALL_START0", 690204);
+define("SCALE_MODE_MANUAL", 690205);
+define("SCALE_SKIP_NONE", 690301);
+define("SCALE_SKIP_SAME", 690302);
+define("SCALE_SKIP_NUMBERS", 690303);
+define("TEXT_ALIGN_TOPLEFT", 690401);
+define("TEXT_ALIGN_TOPMIDDLE", 690402);
+define("TEXT_ALIGN_TOPRIGHT", 690403);
+define("TEXT_ALIGN_MIDDLELEFT", 690404);
+define("TEXT_ALIGN_MIDDLEMIDDLE", 690405);
+define("TEXT_ALIGN_MIDDLERIGHT", 690406);
+define("TEXT_ALIGN_BOTTOMLEFT", 690407);
+define("TEXT_ALIGN_BOTTOMMIDDLE", 690408);
+define("TEXT_ALIGN_BOTTOMRIGHT", 690409);
+define("POSITION_TOP", 690501);
+define("POSITION_BOTTOM", 690502);
+define("LABEL_POS_LEFT", 690601);
+define("LABEL_POS_CENTER", 690602);
+define("LABEL_POS_RIGHT", 690603);
+define("LABEL_POS_TOP", 690604);
+define("LABEL_POS_BOTTOM", 690605);
+define("LABEL_POS_INSIDE", 690606);
+define("LABEL_POS_OUTSIDE", 690607);
+define("ORIENTATION_HORIZONTAL", 690701);
+define("ORIENTATION_VERTICAL", 690702);
+define("ORIENTATION_AUTO", 690703);
+define("LEGEND_NOBORDER", 690800);
+define("LEGEND_BOX", 690801);
+define("LEGEND_ROUND", 690802);
+define("LEGEND_VERTICAL", 690901);
+define("LEGEND_HORIZONTAL", 690902);
+define("LEGEND_FAMILY_BOX", 691051);
+define("LEGEND_FAMILY_CIRCLE", 691052);
+define("LEGEND_FAMILY_LINE", 691053);
+define("DISPLAY_AUTO", 691001);
+define("DISPLAY_MANUAL", 691002);
+define("LABELING_ALL", 691011);
+define("LABELING_DIFFERENT", 691012);
+define("BOUND_MIN", 691021);
+define("BOUND_MAX", 691022);
+define("BOUND_BOTH", 691023);
+define("BOUND_LABEL_POS_TOP", 691031);
+define("BOUND_LABEL_POS_BOTTOM", 691032);
+define("BOUND_LABEL_POS_AUTO", 691033);
+define("CAPTION_LEFT_TOP", 691041);
+define("CAPTION_RIGHT_BOTTOM", 691042);
+define("GRADIENT_SIMPLE", 691051);
+define("GRADIENT_EFFECT_CAN", 691052);
+define("LABEL_TITLE_NOBACKGROUND", 691061);
+define("LABEL_TITLE_BACKGROUND", 691062);
+define("LABEL_POINT_NONE", 691071);
+define("LABEL_POINT_CIRCLE", 691072);
+define("LABEL_POINT_BOX", 691073);
+define("ZONE_NAME_ANGLE_AUTO", 691081);
+define("PI", 3.14159265);
+define("ALL", 69);
+define("NONE", 31);
+define("AUTO", 690000);
+define("OUT_OF_SIGHT", -10000000000000);
+
+/**
+ * pImage
+ */
+/* Image map handling */
+define("IMAGE_MAP_STORAGE_FILE", 680001);
+define("IMAGE_MAP_STORAGE_SESSION", 680002);
+/* Last generated chart layout */
+define("CHART_LAST_LAYOUT_REGULAR", 680011);
+define("CHART_LAST_LAYOUT_STACKED", 680012);
+/* ImageMap string delimiter */
+define("IMAGE_MAP_DELIMITER", chr(1));
+
+/**
+ * pIndicator
+ */
+define("INDICATOR_CAPTION_DEFAULT", 700001);
+define("INDICATOR_CAPTION_EXTENDED", 700002);
+define("INDICATOR_CAPTION_INSIDE", 700011);
+define("INDICATOR_CAPTION_BOTTOM", 700012);
+define("INDICATOR_VALUE_BUBBLE", 700021);
+define("INDICATOR_VALUE_LABEL", 700022);
+
+/**
+ * pPie
+ */
+/* Class return codes */
+define("PIE_NO_ABSCISSA", 140001);
+define("PIE_NO_DATASERIE", 140002);
+define("PIE_SUMISnull", 140003);
+define("PIE_RENDERED", 140000);
+define("PIE_LABEL_COLOR_AUTO", 140010);
+define("PIE_LABEL_COLOR_MANUAL", 140011);
+define("PIE_VALUE_NATURAL", 140020);
+define("PIE_VALUE_PERCENTAGE", 140021);
+define("PIE_VALUE_INSIDE", 140030);
+define("PIE_VALUE_OUTSIDE", 140031);
+
+/**
+ * pRadar
+ */
+define("SEGMENT_HEIGHT_AUTO", 690001);
+define("RADAR_LAYOUT_STAR", 690011);
+define("RADAR_LAYOUT_CIRCLE", 690012);
+define("RADAR_LABELS_ROTATED", 690021);
+define("RADAR_LABELS_HORIZONTAL", 690022);
+
+/**
+ * pScatter
+ */
+define("SCATTER_MISSING_X_SERIE", 190001);
+define("SCATTER_MISSING_Y_SERIE", 190002);
+
+/**
+ * pSplit
+ */
+define("TEXT_POS_TOP", 690001);
+define("TEXT_POS_RIGHT", 690002);
+
+/**
+ * pSpring
+ */
+define("NODE_TYPE_FREE", 690001);
+define("NODE_TYPE_CENTRAL", 690002);
+define("NODE_SHAPE_CIRCLE", 690011);
+define("NODE_SHAPE_TRIANGLE", 690012);
+define("NODE_SHAPE_SQUARE", 690013);
+define("ALGORITHM_RANDOM", 690021);
+define("ALGORITHM_WEIGHTED", 690022);
+define("ALGORITHM_CIRCULAR", 690023);
+define("ALGORITHM_CENTRAL", 690024);
+define("LABEL_CLASSIC", 690031);
+define("LABEL_LIGHT", 690032);
+
+/**
+ * pStock
+ */
+define("STOCK_MISSING_SERIE", 180001);
+
+/**
+ * pSurface
+ */
+define("UNKNOWN", 0.123456789);
+define("IGNORED", -1);
+define("LABEL_POSITION_LEFT", 880001);
+define("LABEL_POSITION_RIGHT", 880002);
+define("LABEL_POSITION_TOP", 880003);
+define("LABEL_POSITION_BOTTOM", 880004);

vendor/szymach/c-pchart/src/Resources/palettes/autumn.color

@@ -0,0 +1,6 @@
+185,106,154,100
+216,137,184,100
+156,192,137,100
+216,243,201,100
+253,232,215,100
+255,255,255,100

vendor/szymach/c-pchart/src/Resources/palettes/blind.color

@@ -0,0 +1,6 @@
+109,152,171,100
+0,39,94,100
+254,183,41,100
+168,177,184,100
+255,255,255,100
+0,0,0,100

vendor/szymach/c-pchart/src/Resources/palettes/evening.color

@@ -0,0 +1,6 @@
+242,245,237,100
+255,194,0,100
+255,91,0,100
+184,0,40,100
+132,0,46,100
+74,192,242,100

vendor/szymach/c-pchart/src/Resources/palettes/kitchen.color

@@ -0,0 +1,6 @@
+155,225,251,100
+197,239,253,100
+189,32,49,100
+35,31,32,100
+255,255,255,100
+0,98,149,100

vendor/szymach/c-pchart/src/Resources/palettes/light.color

@@ -0,0 +1,7 @@
+239,210,121,100
+149,203,233,100
+2,71,105,100
+175,215,117,100
+44,87,0,100
+222,157,127,100
+

vendor/szymach/c-pchart/src/Resources/palettes/navy.color

@@ -0,0 +1,6 @@
+25,78,132,100
+59,107,156,100
+31,36,42,100
+55,65,74,100
+96,187,34,100
+242,186,187,100

vendor/szymach/c-pchart/src/Resources/palettes/shade.color

@@ -0,0 +1,6 @@
+117,113,22,100
+174,188,33,100
+217,219,86,100
+0,71,127,100
+76,136,190,100
+141,195,233,100

vendor/szymach/c-pchart/src/Resources/palettes/spring.color

@@ -0,0 +1,6 @@
+146,123,81,100
+168,145,102,100
+128,195,28,100
+188,221,90,100
+255,121,0,100
+251,179,107,100

vendor/szymach/c-pchart/src/Resources/palettes/summer.color

@@ -0,0 +1,6 @@
+253,184,19,100
+246,139,31,100
+241,112,34,100
+98,194,204,100
+228,246,248,100
+238,246,108,100

vendor/szymach/c-pchart/src/Services/pChartFactory.php

@@ -0,0 +1,134 @@
+<?php
+namespace CpChart\Services;
+
+use CpChart\Classes\pData;
+use CpChart\Classes\pImage;
+
+/**
+ * A simple service class utilizing the Factory design pattern. It has three 
+ * class specific methods, as well as a generic loader for the chart classes.
+ *
+ * @author szymach @ http://github.com/szymach
+ */
+class pChartFactory
+{
+    private $namespace = 'CpChart\Classes\\';
+    
+    /**
+     * Loads a new chart class (scatter, pie etc.). Some classes require instances of
+     * pImage and pData classes passed into their constructor. These classes are: 
+     * pBubble, pPie, pScatter, pStock, pSurface and pIndicator. Otherwise the 
+     * pChartObject and pDataObject parameters are redundant.
+     * 
+     * ATTENTION! SOME OF THE CHARTS NEED TO BE DRAWN VIA A METHOD FROM THE
+     * pIMAGE CLASS (ex. 'drawBarChart'), NOT THROUGH THIS METHOD! READ THE 
+     * DOCUMENTATION FOR MORE DETAILS.
+     * 
+     * @param string $chartType - type of the chart to be loaded (for example 'pie', not 'pPie')
+     * @param pImage $pChartObject
+     * @param pData $pDataObject
+     * @return \CpChart\Classes\$chartName
+     */
+    public function newChart(
+        $chartType,
+        pImage $pChartObject = null, 
+        pData $pDataObject = null
+    ) {
+        $this->checkChartType($chartType);
+        $className = $this->namespace.'p'.ucfirst($chartType);
+        if (!class_exists($className)) {
+            throw new \Exception('The requested chart class does not exist!');
+        }
+        return new $className($pChartObject, $pDataObject);
+    }
+    
+    /**
+     * Checks if the requested chart type is created via one of the methods in
+     * the pDraw class, instead through a seperate class. If a method in pDraw
+     * exists, an exception with proper information is thrown.
+     * 
+     * @param string $chartType
+     * @throws \Exception
+     */
+    private function checkChartType($chartType)
+    {
+        $methods = array(
+            'draw'.ucfirst($chartType).'Chart',
+            'draw'.ucfirst($chartType)
+        );
+        foreach ($methods as $method) {
+            if (method_exists($this->namespace.'pImage', $method)) {
+                throw new \Exception(
+                    'The requested chart is not a seperate class, to draw it you'
+                  . ' need to call the "'.$method.'" method on the pImage object'
+                  . ' after populating it with data!'
+                  . ' Check the documentation on library\'s website for details.'
+                );
+            }
+        }
+    }
+    
+    /**
+     * Creates a new pData class with an option to pass the data to form a serie.
+     * 
+     * @param array $points - points to be added to serie
+     * @param string $serieName - name of the serie
+     * @return pData
+     */
+    public function newData(array $points = array(), $serieName = "Serie1")
+    {
+        $className = $this->namespace.'pData';
+        $data = new $className(); 
+        if (count($points) > 0) {
+            $data->addPoints($points, $serieName);
+        }
+        return $data;
+    }
+    
+    /**
+     * Create a new pImage class. It requires the size of axes to be properly
+     * constructed.
+     * 
+     * @param integer $XSize - length of the X axis
+     * @param integer $YSize - length of the Y axis
+     * @param pData $DataSet - pData class populated with points
+     * @param boolean $TransparentBackground
+     * @return pImage
+     */
+    public function newImage(
+        $XSize,
+        $YSize,
+        \CpChart\Classes\pData $DataSet = null,
+        $TransparentBackground = false
+    ) {
+        $className = $this->namespace.'pImage';
+        return new $className(
+            $XSize,
+            $YSize,
+            $DataSet,
+            $TransparentBackground
+        );
+    }
+    
+    /**
+     * Create one of the pBarcode classes. Only the number is required (39 or 128),
+     * the class name is contructed on the fly. Passing the constructor's parameters
+     * is also available, but not mandatory.
+     * 
+     * @param string $number - number identifing the pBarcode class ("39" or "128")
+     * @param string $BasePath - optional path for the file containing the class data
+     * @param boolean $EnableMOD43
+     * @return pBarcode(39|128)
+     * @throws \Exception
+     */
+    public function getBarcode($number, $BasePath = "", $EnableMOD43 = false)
+    {
+        if ($number != "39" && $number != "128") {
+            throw new \Exception(
+                'The barcode class for the provided number does not exist!'
+            );
+        }
+        $className = $this->namespace."pBarcode".$number;
+        return new $className($BasePath, $EnableMOD43);
+    }
+}