/**
 * Copyright (c) 2011, The University of Southampton and the individual contributors.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 *   *  Redistributions of source code must retain the above copyright notice,
 *      this list of conditions and the following disclaimer.
 *
 *   *  Redistributions in binary form must reproduce the above copyright notice,
 *      this list of conditions and the following disclaimer in the documentation
 *      and/or other materials provided with the distribution.
 *
 *   *  Neither the name of the University of Southampton nor the names of its
 *      contributors may be used to endorse or promote products derived from this
 *      software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
package org.openimaj.image.feature.dense.gradient.dsift;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;
import java.util.StringTokenizer;

import org.openimaj.feature.ByteFV;

/**
 * Dense SIFT keypoint with a location and byte feature vector. Also includes
 * the energy of the feature prior to normalisation in case low-contrast
 * features need removing.
 *
 * @author Jonathon Hare (jsh2@ecs.soton.ac.uk)
 *
 */
public class ByteDSIFTKeypoint
                extends
                        AbstractDSIFTKeypoint<ByteFV, byte[]>
{
        static final long serialVersionUID = 12345545L;

        /**
         * Construct with the default feature vector length for SIFT (128).
         */
        public ByteDSIFTKeypoint() {
                this(DEFAULT_LENGTH);
        }

        /**
         * Construct with the given feature vector length.
         *
         * @param length
         *            the length of the feature vector
         */
        public ByteDSIFTKeypoint(final int length) {
                this.descriptor = new byte[length];
        }

        /**
         * Construct with the given parameters.
         *
         * @param x
         *            the x-ordinate of the keypoint
         * @param y
         *            the y-ordinate of the keypoint
         * @param descriptor
         *            the feature vector of the keypoint
         * @param energy
         *            the energy of the keypoint
         */
        public ByteDSIFTKeypoint(final float x, final float y, final byte[] descriptor, final float energy) {
                this.x = x;
                this.y = y;
                this.descriptor = descriptor;
                this.energy = energy;
        }

        /**
         * Construct with the given parameters. The float version of the descriptor
         * is converted to bytes by multiplying each bin by 512, clipping to 255 and
         * then subtracting 128.
         *
         * @param x
         *            the x-ordinate of the keypoint
         * @param y
         *            the y-ordinate of the keypoint
         * @param fdescriptor
         *            the flaot version of feature vector of the keypoint
         * @param energy
         *            the energy of the keypoint
         */
        public ByteDSIFTKeypoint(final float x, final float y, final float[] fdescriptor, final float energy) {
                this.x = x;
                this.y = y;
                this.energy = energy;
                this.descriptor = new byte[fdescriptor.length];

                for (int i = 0; i < descriptor.length; i++) {
                        final int intval = (int) (512.0 * fdescriptor[i]);
                        descriptor[i] = (byte) (Math.min(255, intval) - 128);
                }
        }

        @Override
        public ByteFV getFeatureVector() {
                return new ByteFV(descriptor);
        }

        @Override
        public String toString() {
                return ("ByteDSIFTKeypoint(" + this.x + ", " + this.y + ")");
        }

        @Override
        public void writeBinary(DataOutput out) throws IOException {
                out.writeFloat(x);
                out.writeFloat(y);
                out.writeFloat(energy);

                out.write(this.descriptor);
        }

        @Override
        public void writeASCII(PrintWriter out) throws IOException {
                /* Output data for the keypoint. */
                out.write(x + " " + y + " " + energy + "\n");

                for (int i = 0; i < descriptor.length; i++) {
                        if (i > 0 && i % 20 == 0)
                                out.println();
                        out.print(" " + (descriptor[i] + 128));
                }
                out.println();
        }

        @Override
        public void readBinary(DataInput in) throws IOException {
                x = in.readFloat();
                y = in.readFloat();
                energy = in.readFloat();
                in.readFully(descriptor);
        }

        @Override
        public void readASCII(Scanner in) throws IOException {
                x = in.nextFloat();
                y = in.nextFloat();
                energy = in.nextFloat();

                int i = 0;
                while (i < descriptor.length) {
                        final String line = in.nextLine();
                        final StringTokenizer st = new StringTokenizer(line);

                        while (st.hasMoreTokens()) {
                                descriptor[i] = (byte) (Integer.parseInt(st.nextToken()) - 128);
                                i++;
                        }
                }
        }
}