/*
 * Java
 *
 * Copyright 2021-2022 MicroEJ Corp. All rights reserved.
 * This library is provided in source code for use, modification and test, subject to license terms.
 * Any modification of the source code will break MicroEJ Corp. warranties on the whole library.
 */
package ej.microvg;

/**
 * Represents a vector image.
 */
public class VectorImage {

    /**
     * Gets a vector image from a path.
     * <p>
     * This method can only retrieve images which are in the internal image format defined by the MicroVG
     * implementation. This operation does not require a dynamic allocation in order to store the image paths.
     * <p>
     * If the resource cannot be retrieved, a {@link VectorGraphicsException} is thrown even if the resource is present
     * but requires a loading step.
     *
     * @param resourcePath
     *            the path to get the image from
     * @return a vector image
     * @throws VectorGraphicsException
     *             if the image could not be retrieved for any reason (see
     *             {@link VectorGraphicsException#getErrorCode()})
     */
    public static VectorImage getImage(String resourcePath) {
        throw new VectorGraphicsException();
    }

    /**
     * Creates an image derived from this image, applying the given color matrix.
     * <p>
     * The returned image is allocated dynamically and must be closed explicitly.
     * <p>
     * The given matrix is a 4x5 color matrix. It is organized like that:
     * <ul>
     * <li>Each line is used to compute a component of the resulting color, in this order: red, green, blue, alpha.</li>
     * <li>The four first columns are multipliers applied to a component of the initial color, in this order: red,
     * green, blue, alpha.</li>
     * <li>The last column is a constant value.</li>
     * </ul>
     * Each component is then computed like that:
     * <code>redMultiplier x redInitialComponent + greenMultiplier x greenInitialComponent + blueMultiplier x blueInitialComponent + constant</code>
     * Each component is clamped between 0x0 and 0xff.
     * <p>
     * Let A, R, G, B be the components of the initial color and the following array a color matrix:
     *
     * <pre>
     * <code>
     * { rR, rG, rB, rA, rC,
     *   gR, gG, gB, gA, gC,
     *   bR, bG, bB, bA, bC,
     *   aR, aG, aB, aA, aC }
     * </code>
     * </pre>
     * <p>
     * The resulting color components are computed as:
     *
     * <pre>
     * resultRed = rR * R + rG * G + rB * B + rA * A + rC
     * resultGreen = gR * R + gG * G + gB * B + gA * A + gC
     * resultBlue = bR * R + bG * G + bB * B + bA * A + bC
     * resultAlpha = aR * R + aG * G + aB * B + aA * A + aC
     * </pre>
     *
     * @param colorMatrix
     *            the color matrix used to transform colors
     * @return the filtered image
     * @throws ArrayIndexOutOfBoundsException
     *             if the given color matrix is shorter than 20 entries
     * @throws VectorGraphicsException
     *             if the image has overlapping paths and the color matrix puts a non-opaque alpha level
     */
    public ResourceVectorImage filterImage(float[] colorMatrix) {
        throw new VectorGraphicsException();
    }

    /**
     * Gets the width of the vector image.
     *
     * @return the width
     */
    public float getWidth() {
        throw new VectorGraphicsException();
    }

    /**
     * Gets the height of the vector image.
     *
     * @return the height
     */
    public float getHeight() {
        throw new VectorGraphicsException();
    }

    /**
     * Gets the duration of the vector image animation if the image is animated, otherwise 0.
     *
     * @return the duration of the animation of the vector image
     */
    public long getDuration() {
        throw new VectorGraphicsException();
    }
}