src/lib-mesh/inter-smooth-diver.hh

Go to the documentation of this file.

/*
 * lib-mesh : Opérations de maillage et lissage.
 * Copyright (C) 2004, Moka Team, Université de Poitiers, Laboratoire SIC
 *               http://www.sic.sp2mi.univ-poitiers.fr/
 * Copyright (C) 2009, Guillaume Damiand, CNRS, LIRIS,
 *               guillaume.damiand@liris.cnrs.fr, http://liris.cnrs.fr/
 *
 * This file is part of lib-mesh
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

//******************************************************************************
#ifndef INTER_SMOOTH_DIVER_HH
#define INTER_SMOOTH_DIVER_HH
//******************************************************************************
#include "mesh-diver.hh"
//******************************************************************************
class CTransformationMatrix;
//******************************************************************************
// @{
//------------------------------------------------------------------------------
class CMesh1InterpolationDiver : public CMesh1Diver
{
protected:
  CVertex FVertex0, FVertex1;

public:
  // @name Constructeur et destructeur
  // @{

  CMesh1InterpolationDiver(int ASx,
                           const CVertex& AVertex0,
                           const CVertex& AVertex1);

  virtual ~CMesh1InterpolationDiver();

  // @}
};
//------------------------------------------------------------------------------
class CMesh2InterpolationDiver : public CMesh2Diver
{
protected:
  const CVertex ** FBottomEdge; /* FSx + 1 */
  const CVertex ** FTopEdge   ; /* FSx + 1 */
  const CVertex ** FLeftEdge  ; /* FSy + 1 */
  const CVertex ** FRightEdge ; /* FSy + 1 */

public:
  // @name Constructeur et destructeur
  // @{

  CMesh2InterpolationDiver(int ASx, int ASy,
                           const CVertex** ABottomEdge /* ASx+1 */,
                           const CVertex** ATopEdge    /* ASx+1 */,
                           const CVertex** ALeftEdge   /* ASy+1 */,
                           const CVertex** ARightEdge  /* ASy+1 */);

  virtual ~CMesh2InterpolationDiver();

  // @}
};
//------------------------------------------------------------------------------
class CMesh3InterpolationDiver : public CMesh3Diver
{
protected:
  const CVertex *** FLeftFace  ; /* (FSy+1)*(FSz+1) */
  const CVertex *** FRightFace ; /* (FSy+1)*(FSz+1) */
  const CVertex *** FFrontFace ; /* (FSz+1)*(FSx+1) */
  const CVertex *** FBackFace  ; /* (FSz+1)*(FSx+1) */
  const CVertex *** FBottomFace; /* (FSx+1)*(FSy+1) */
  const CVertex *** FTopFace   ; /* (FSx+1)*(FSy+1) */

public:
  // @name Constructeur et destructeur
  // @{

  CMesh3InterpolationDiver(int ASx, int ASy, int ASz,
                           const CVertex*** ALeftFace   /* (ASy+1)*(ASz+1) */,
                           const CVertex*** ARightFace  /* (ASy+1)*(ASz+1) */,
                           const CVertex*** AFrontFace  /* (ASx+1)*(ASz+1) */,
                           const CVertex*** ABackFace   /* (ASx+1)*(ASz+1) */,
                           const CVertex*** ABottomFace /* (ASx+1)*(ASy+1) */,
                           const CVertex*** ATopFace    /* (ASx+1)*(ASy+1) */);

  virtual ~CMesh3InterpolationDiver();

  // @}
};

// @}
//******************************************************************************
// @{
//******************************************************************************
class CMesh1LinearDiver : public CMesh1InterpolationDiver
{
public:
  // @name Constructeur et destructeur
  // @{

  CMesh1LinearDiver(int ASx,
                    const CVertex& AVertex0,
                    const CVertex& AVertex1);

  virtual ~CMesh1LinearDiver();

  // @}
  // @name Méthode de calcul des plongements
  // @{

  virtual CVertex computeCurrentVertex() const;

  // @}
};
//------------------------------------------------------------------------------
class CMesh2LinearDiver : public CMesh2InterpolationDiver
{
private:
  const CVertex * FP00, * FP01, * FP10, * FP11;
  const CVertex * FPi0, * FP0j, * FP1j, * FPi1;

public:
  // @name Constructeur et destructeur
  // @{

  CMesh2LinearDiver(int ASx, int ASy,
                    const CVertex ** ABottomEdge /* ASx+1 */,
                    const CVertex ** ATopEdge    /* ASx+1 */,
                    const CVertex ** ALeftEdge   /* ASy+1 */,
                    const CVertex ** ARightEdge  /* ASy+1 */);

  virtual ~CMesh2LinearDiver();

  // @}
  // @name Accesseurs
  // @{

  virtual void setIx(int AIx);

  virtual void setIy(int AIy);

  // @}
  // @name Méthode de calcul des plongements
  // @{

  virtual CVertex computeCurrentVertex() const;

  // @}
};
//------------------------------------------------------------------------------
class CMesh3LinearDiver : public CMesh3InterpolationDiver
{
private:
  const CVertex * FP000, * FP001, * FP010, * FP011;
  const CVertex * FP100, * FP101, * FP110, * FP111;

  const CVertex * FPi00, * FP0j0, * FP00k;
  const CVertex * FPi11, * FP1j1, * FP11k;

  const CVertex * FPi10, * FP0j1, * FP10k;
  const CVertex * FPi01, * FP1j0, * FP01k;

  const CVertex * FP0jk, * FPi0k, * FPij0;
  const CVertex * FP1jk, * FPi1k, * FPij1;

public:
  // @name Constructeur et destructeur
  // @{

  CMesh3LinearDiver(int ASx, int ASy, int ASz,
                    const CVertex*** ALeftFace   /* (ASy+1)*(ASz+1) */,
                    const CVertex*** ARightFace  /* (ASy+1)*(ASz+1) */,
                    const CVertex*** AFrontFace  /* (ASx+1)*(ASz+1) */,
                    const CVertex*** ABackFace   /* (ASx+1)*(ASz+1) */,
                    const CVertex*** ABottomFace /* (ASx+1)*(ASy+1) */,
                    const CVertex*** ATopFace    /* (ASx+1)*(ASy+1) */);

  virtual ~CMesh3LinearDiver();

  // @}
  // @name Accesseurs
  // @{

  virtual void setIx(int AIx);

  virtual void setIy(int AIy);

  virtual void setIz(int AIz);

  // @}
  // @name Méthode de calcul des plongements
  // @{

  virtual CVertex computeCurrentVertex() const;

  // @}
};

// @}
//******************************************************************************
// @{
//******************************************************************************
class CMesh1SmoothingDiver : public CMesh1Diver
{
protected:
  CVector FTX;
  CVector FControl[3];

public:
  // @name Constructeur, initialisateur et destructeur
  // @{

  CMesh1SmoothingDiver(int ASx,
                       const CTransformationMatrix & AMethod,
                       const CVertex * AControlPoints);

  virtual ~CMesh1SmoothingDiver();

  // @}
  // @name Accesseurs
  // @{

  virtual void setIx(int AIx);

  // @}
  // @name Méthode de calcul des plongements
  // @{

  virtual CVertex computeCurrentVertex() const;

  // @}
};
//------------------------------------------------------------------------------
class CMesh2SmoothingDiver : public CMesh2Diver
{
protected:
  const CTransformationMatrix * FMethod;

  CMesh1SmoothingDiver * FCurbsY[4];
  CMesh1SmoothingDiver * FCurbX;

public:
  // @name Constructeur et destructeur
  // @{

  CMesh2SmoothingDiver(int ASx, int ASy,
                       const CTransformationMatrix& AMethod,
                       const CVertex** AControlPoints);

  virtual ~CMesh2SmoothingDiver();

  // @}
  // @name Accesseurs
  // @{

  virtual void setIx(int AIx);

  virtual void setIy(int AIy);

  // @}
  // @name Méthode de calcul des plongements
  // @{

  virtual CVertex computeCurrentVertex() const;

  // @}
};
//------------------------------------------------------------------------------
class CMesh3SmoothingDiver : public CMesh3Diver
{
protected:
  const CTransformationMatrix * FMethod;

  CMesh2SmoothingDiver * FSurfacesYZ[4];
  CMesh1SmoothingDiver * FCurbX;

public:
  // @name Constructeur et destructeur
  // @{

  CMesh3SmoothingDiver(int ASx, int ASy, int ASz,
                       const CTransformationMatrix& AMethod,
                       const CVertex*** AControlPoints);

  virtual ~CMesh3SmoothingDiver();

  // @}
  // @name Accesseurs
  // @{

  virtual void setIx(int AIx);

  virtual void setIy(int AIy);

  virtual void setIz(int AIz);

  // @}
  // @name Méthode de calcul des plongements
  // @{

  virtual CVertex computeCurrentVertex() const;

  // @}
};
//******************************************************************************
#include INCLUDE_INLINE("inter-smooth-diver.icc")
//******************************************************************************
#endif // INTER_SMOOTH_DIVER_HH
//******************************************************************************

---