/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkTextureMapToPlane.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
/**
 * @class   vtkTextureMapToPlane
 * @brief   generate texture coordinates by mapping points to plane
 *
 * vtkTextureMapToPlane is a filter that generates 2D texture coordinates
 * by mapping input dataset points onto a plane. The plane can either be
 * user specified or generated automatically. (A least squares method is
 * used to generate the plane automatically.)
 *
 * There are two ways you can specify the plane. The first is to provide a
 * plane normal. In this case the points are projected to a plane, and the
 * points are then mapped into the user specified s-t coordinate range. For
 * more control, you can specify a plane with three points: an origin and two
 * points defining the two axes of the plane. (This is compatible with the
 * vtkPlaneSource.) Using the second method, the SRange and TRange vectors
 * are ignored, since the presumption is that the user does not want to scale
 * the texture coordinates; and you can adjust the origin and axes points to
 * achieve the texture coordinate scaling you need. Note also that using the
 * three point method the axes do not have to be orthogonal.
 *
 * @sa
 *  vtkPlaneSource vtkTextureMapToCylinder
 * vtkTextureMapToSphere vtkThresholdTextureCoords
 */

#ifndef vtkTextureMapToPlane_h
#define vtkTextureMapToPlane_h

#include "vtkDataSetAlgorithm.h"
#include "vtkFiltersTextureModule.h" // For export macro

class VTKFILTERSTEXTURE_EXPORT vtkTextureMapToPlane : public vtkDataSetAlgorithm
{
public:
  vtkTypeMacro(vtkTextureMapToPlane, vtkDataSetAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  /**
   * Construct with s,t range=(0,1) and automatic plane generation turned on.
   */
  static vtkTextureMapToPlane* New();

  ///@{
  /**
   * Specify a point defining the origin of the plane. Used in conjunction with
   * the Point1 and Point2 ivars to specify a map plane.
   */
  vtkSetVector3Macro(Origin, double);
  vtkGetVectorMacro(Origin, double, 3);
  ///@}

  ///@{
  /**
   * Specify a point defining the first axis of the plane.
   */
  vtkSetVector3Macro(Point1, double);
  vtkGetVectorMacro(Point1, double, 3);
  ///@}

  ///@{
  /**
   * Specify a point defining the second axis of the plane.
   */
  vtkSetVector3Macro(Point2, double);
  vtkGetVectorMacro(Point2, double, 3);
  ///@}

  ///@{
  /**
   * Specify plane normal. An alternative way to specify a map plane. Using
   * this method, the object will scale the resulting texture coordinate
   * between the SRange and TRange specified.
   */
  vtkSetVector3Macro(Normal, double);
  vtkGetVectorMacro(Normal, double, 3);
  ///@}

  ///@{
  /**
   * Specify s-coordinate range for texture s-t coordinate pair.
   */
  vtkSetVector2Macro(SRange, double);
  vtkGetVectorMacro(SRange, double, 2);
  ///@}

  ///@{
  /**
   * Specify t-coordinate range for texture s-t coordinate pair.
   */
  vtkSetVector2Macro(TRange, double);
  vtkGetVectorMacro(TRange, double, 2);
  ///@}

  ///@{
  /**
   * Turn on/off automatic plane generation.
   */
  vtkSetMacro(AutomaticPlaneGeneration, vtkTypeBool);
  vtkGetMacro(AutomaticPlaneGeneration, vtkTypeBool);
  vtkBooleanMacro(AutomaticPlaneGeneration, vtkTypeBool);
  ///@}

protected:
  vtkTextureMapToPlane();
  ~vtkTextureMapToPlane() override = default;

  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  void ComputeNormal(vtkDataSet* output);

  double Origin[3];
  double Point1[3];
  double Point2[3];
  double Normal[3];
  double SRange[2];
  double TRange[2];
  vtkTypeBool AutomaticPlaneGeneration;

private:
  vtkTextureMapToPlane(const vtkTextureMapToPlane&) = delete;
  void operator=(const vtkTextureMapToPlane&) = delete;
};

#endif