/*
 * Copyright (C) 2003, 2004 Jason Bevins (original libnoise code)
 * Copyright  2010 Thomas J. Hodge (java port of libnoise)
 * 
 * This file is part of libnoiseforjava.
 * 
 * libnoiseforjava is a Java port of the C++ library libnoise, which may be found at 
 * http://libnoise.sourceforge.net/.  libnoise was developed by Jason Bevins, who may be 
 * contacted at jlbezigvins@gmzigail.com (for great email, take off every 'zig').
 * Porting to Java was done by Thomas Hodge, who may be contacted at
 * libnoisezagforjava@gzagmail.com (remove every 'zag').
 * 
 * libnoiseforjava 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.
 * 
 * libnoiseforjava 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
 * libnoiseforjava.  If not, see <http://www.gnu.org/licenses/>.
 * 
 */

package libnoiseforjava.module;

import libnoiseforjava.Interp;
import libnoiseforjava.Misc;
import libnoiseforjava.exception.ExceptionInvalidParam;

public class Curve extends ModuleBase
{
   /// Noise module that maps the output value from a source module onto an
   /// arbitrary function curve.
   ///
   /// This noise module maps the output value from the source module onto an
   /// application-defined curve.  This curve is defined by a number of
   /// <i>control points</i>; each control point has an <i>input value</i>
   /// that maps to an <i>output value</i>.
   ///
   /// To add the control points to this curve, call the addControlPoint()
   /// method.  Note that the class ControlPoint follows the class Curve in
   /// this file.
   ///
   /// Since this curve is a cubic spline, an application must add a minimum
   /// of four control points to the curve.  If this is not done, the
   /// getValue() method fails.  Each control point can have any input and
   /// output value, although no two control points can have the same input
   /// value.  There is no limit to the number of control points that can be
   /// added to the curve.  
   ///
   /// This noise module requires one source module

   int controlPointCount;
   ControlPoint[] controlPoints;

   public Curve (ModuleBase sourceModule) throws ExceptionInvalidParam
   {
      super(1);
      setSourceModule(0, sourceModule);
      controlPointCount = 0;
      controlPoints= new ControlPoint[1];
      controlPoints[0] = new ControlPoint(0.0, 0.0);
   }

   public void addControlPoint (double inputValue, double outputValue)
      throws ExceptionInvalidParam
   {
      // Find the insertion point for the new control point and insert the new
      // point at that position.  The control point array will remain sorted by
      // input value.
      int insertionPos = findInsertionPos(inputValue);
      insertAtPos (insertionPos, inputValue, outputValue);
   }

   public void clearAllControlPoints ()
   {
      controlPoints = null;
      controlPointCount = 0;
   }

   public int findInsertionPos (double inputValue) throws ExceptionInvalidParam
   {
      int insertionPos;
      for (insertionPos = 0; insertionPos < controlPointCount; insertionPos++)
      {
         if (inputValue < controlPoints[insertionPos].inputValue)
            // We found the array index in which to insert the new control point.
            // Exit now.
            break;
         else if (inputValue == controlPoints[insertionPos].inputValue)
            // Each control point is required to contain a unique input value, so
            // throw an exception.
            throw new ExceptionInvalidParam("Invalid Parameter in Curve");
      }
      return insertionPos;
   }

   public double getValue (double x, double y, double z)
   {
      assert (sourceModules[0] != null);
      assert (controlPointCount >= 4);

      // Get the output value from the source module.
      double sourceModuleValue = sourceModules[0].getValue (x, y, z);

      // Find the first element in the control point array that has an input value
      // larger than the output value from the source module.
      int indexPos;
      for (indexPos = 0; indexPos < controlPointCount; indexPos++)
      {
         if (sourceModuleValue < controlPoints[indexPos].inputValue)
            break;

      }

      // Find the four nearest control points so that we can perform cubic
      // interpolation.
      int index0 = Misc.ClampValue (indexPos - 2, 0, controlPointCount - 1);
      int index1 = Misc.ClampValue (indexPos - 1, 0, controlPointCount - 1);
      int index2 = Misc.ClampValue (indexPos    , 0, controlPointCount - 1);
      int index3 = Misc.ClampValue (indexPos + 1, 0, controlPointCount - 1);

      // If some control points are missing (which occurs if the value from the
      // source module is greater than the largest input value or less than the
      // smallest input value of the control point array), get the corresponding
      // output value of the nearest control point and exit now.
      if (index1 == index2) {
         return controlPoints[index1].outputValue;
      }

      // Compute the alpha value used for cubic interpolation.
      double input0 = controlPoints[index1].inputValue;
      double input1 = controlPoints[index2].inputValue;
      double alpha = (sourceModuleValue - input0) / (input1 - input0);

      // Now perform the cubic interpolation given the alpha value.
      return Interp.cubicInterp(
            controlPoints[index0].outputValue,
            controlPoints[index1].outputValue,
            controlPoints[index2].outputValue,
            controlPoints[index3].outputValue,
            alpha);
   }

   public void insertAtPos (int insertionPos, double inputValue,
         double outputValue)
   {
      // Make room for the new control point at the specified position within the
      // control point array.  The position is determined by the input value of
      // the control point; the control points must be sorted by input value
      // within that array.
      ControlPoint[] newControlPoints = new ControlPoint[controlPointCount + 1];
      
      for (int t = 0; t < (controlPointCount + 1); t++)
         newControlPoints[t] = new ControlPoint();
      
      for (int i = 0; i < controlPointCount; i++) {
         if (i < insertionPos) {
            newControlPoints[i] = controlPoints[i];
         } else {
            newControlPoints[i + 1] = controlPoints[i];
         }
      }

      controlPoints = newControlPoints;
      ++controlPointCount;

      // Now that we've made room for the new control point within the array, add
      // the new control point.
      controlPoints[insertionPos].inputValue  = inputValue;
      controlPoints[insertionPos].outputValue = outputValue;
   }
}


/// This class defines a control point.
///
/// Control points are used for defining splines.
class ControlPoint
{
   /// The input value.
   double inputValue;

   /// The output value that is mapped from the input value.
   double outputValue;
   
   ControlPoint()
   {
      inputValue = 0.0;
      outputValue = 0.0;
   }
   
   ControlPoint(double inputValue, double outputValue)
   {
      this.inputValue = inputValue;
      this.outputValue = outputValue;
   }
   
   
   
}