Shape.hxx

Go to the documentation of this file.

/*
  This file is part of MURE,
  Copyright (C) 2007-2021 MURE developers.
 
  MURE 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.
 
  MURE 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 MURE.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef _Shape_HXX_
#define _Shape_HXX_
 
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <algorithm>
 
#include "TReference.hxx"
#include "MureConstant.hxx"
#include "SurfaceCard.hxx"
 
class SurfaceCard;
 
using namespace std;
 
class Shape;
class MathNode;
 
typedef Reference_ptr < Shape > Shape_ptr;
 
 
class Shape : public TReference
{
  public :
    Shape(); 
    Shape(const Shape  &s); 
    ~Shape() override; 
    virtual Shape_ptr Clone(int count = 0) = 0; 
 
    Shape_ptr Not(); 
    virtual void CalculNot() {} 
    void NewNot()
    {
        if(fNot) CalculNot();   
    }
    void    SetClone(Shape_ptr clone)
    {
        fCloneShape = clone;   
    }
    void    SetClone2Not(); 
 
    int GetSign()
    {
        return fSign;   
    }
    void    SetSign(int s)
    {
        fSign = s;   
    }
 
    void SetOutermostShape(bool flag = true)
    {
        fOutermostShape = flag;
    }
 
 
    virtual unsigned IsBrick()
    {
        return 0;   
    }
    virtual unsigned IsCylinder()
    {
        return 0;   
    }
    virtual unsigned IsFullVoid()
    {
        return 0;   
    }
    virtual unsigned IsHexagon()
    {
        return 0;   
    }
    virtual unsigned IsNode()
    {
        return 0;   
    }
    virtual unsigned IsPlane()
    {
        return 0;   
    }
    virtual unsigned IsSphere()
    {
        return 0;   
    }
    virtual unsigned IsTube()
    {
        return 0;   
    }
    virtual unsigned IsFull()
    {
        return 0;   
    }
    virtual unsigned IsVoid()
    {
        return 0;   
    }
    virtual unsigned IsZTorus()
    {
        return 0;   
    }
    bool IsInfinite()
    {
        return fInfinite;   
    }
 
 
    virtual double  GetVolume()
    {
        return fVolume;
    }
    void    SetVolume(double V)
    {
        fVolume = V;   
    }
 
 
    virtual double  GetArea()
    {
        return fArea;
    }
    void    SetArea(double S)
    {
        fArea = S;   
    }
 
    virtual void SetMirrorBoundary(bool state = true); 
    virtual void SetTopBottomPlanesOpen()
    {
        fOpenZPlanes = true;   
    }
    virtual bool IsTopBottomPlanesOpen()
    {
        return fOpenZPlanes;   
    }
    virtual void SetSidePlanesOpen()
    {
        fOpenXYPlanes = true;   
    }
    virtual bool IsSidePlanesOpen()
    {
        return fOpenXYPlanes;   
    }
    virtual void SetWhiteBoundary(bool state = true)
    {
        fWhiteBoundary = state;   
    }
 
 
    virtual void SetPeriodicBoundary(bool state = true, string TopBottPlaneBC = "mirror") {};
    virtual bool IsMirrorBoundary()
    {
        return fMirrorBoundary;   
    }
    virtual bool IsWhiteBoundary()
    {
        return fWhiteBoundary;   
    }
    virtual bool IsPeriodicBoundary()
    {
        return fPeriodicBoundary;   
    }
 
 
 
    virtual void Rotate(double phi, double theta = 0, double psi = 0, double *center = nullptr, int count = 0) = 0;
 
    virtual void Translate(double dx, double dy, double dz, int count = 0) = 0;
 
    virtual unsigned Add(Shape_ptr OtherShape)
    {
        return 0;
    }
    virtual void ReplaceLeaf(int i, Shape_ptr OtherShape) {}
 
 
 
    virtual unsigned IsIncluded(Shape_ptr OtherShape) = 0;
 
 
    virtual unsigned IsDisjoint(Shape_ptr OtherShape) = 0;
 
 
 
    unsigned    AddInsideShape(Shape_ptr OtherShape);
 
 
    unsigned AddOriginalInsideShape(Shape_ptr OtherShape)
    {
        fOriginalInsideShape.push_back(OtherShape);
        return 1;
    }
    void      ClearOriginalInsideShape()
    {
        fOriginalInsideShape.clear();   
    }
    void      ClearInsideShape()
    {
        fInsideShape.clear();   
    }
    unsigned GetInsideShapeSize()
    {
        return fInsideShape.size();   
    }
    unsigned GetOriginalInsideShapeSize()
    {
        return fOriginalInsideShape.size();   
    }
    void      SetInsideShape(int i, Shape_ptr S)
    {
        fInsideShape[i] = S;   
    }
    void      SetOriginalInsideShape(int i, Shape_ptr S)
    {
        fOriginalInsideShape[i] = S;   
    }
    Shape_ptr  GetInsideShape(int i)
    {
        return fInsideShape[i];   
    }
    Shape_ptr  GetOriginalInsideShape(int i)
    {
        return fOriginalInsideShape[i];   
    }
 
 
    virtual void Copy(Shape_ptr S) {} 
    virtual Shape_ptr GetLeaf(int i)
    {
        Shape_ptr t(nullptr);    
        return t;
    }
    virtual int GetNumberOfLeaves()
    {
        return 0;   
    }
    string GetShapeName(); 
    virtual int NumberOfShapes()
    {
        return 1;   
    }
 
    void SetDebugName(string str)
    {
        fDebugName = str;   
    }
    string GetDebugName()
    {
        return fDebugName;   
    }
 
 
    virtual void    SetUniverse(int u = - 1);
    virtual void    SetFill(int f)
    {
        fFill = f;   
    }
    int     GetFill()
    {
        return fFill;   
    }
    int     GetUniverse()
    {
        return fUniverse;   
    }
 
    void    IncrementSurface(double S)
    {
        fArea += S;   
    }
 
    virtual double  GetVirtualSphereRadius()
    {
        return fVirtualSphereR;   
    }
    virtual double  *GetVirtualSphereCenter()
    {
        return fVirtualSphereO;   
    }
    
    virtual void RemoveSurface();
 
    virtual string  Print()
    {
        return "Oups! Print function of shape should not be called";   
    }
    virtual void PrintX(int count = 0); 
    virtual void PrintY(int count = 0); 
 
#ifdef _PTODEBUG_
    virtual void PrintLatex(int count = 0); 
    static  void AddLatexLine(char *txt)
    {
        BeginLatex();    
        DEBUGFILE << txt << "\\\\ " << endl;
    }
    static  void BeginLatex(); 
    static  void EndLatex(); 
#endif
 
 
    virtual bool PointInShape(double *P, int border)
    {
        return false;
    }
 
    virtual void SetLinkedPlane(Shape_ptr P)
    {
        fLinkedPlane = P;   
    }
    virtual void ReplaceNode(Shape_ptr C) {} 
 
    virtual SurfaceCard *GetSurfaceCard()
    {
        return nullptr;
    }
    virtual SurfaceCard *GetSurfaceCard(int i)
    {
        return nullptr;
    }
    virtual void ResetIsDefinedSurfaceCalled() {}
 
    virtual void Simplify(bool violent = false) {}
 
    virtual void SetMouvement(bool state = true)
    {
        fMouvement = state;   
    }
    virtual void UnSetMouvement(); 
    bool GetMouvement()
    {
        return fMouvement;   
    }
 
    virtual void DevElague(int count = 0, bool violent = false) {}
    void SetViolentSimplify(bool Allowed = true); 
    void SetFreezeSimplify(bool flag = true){fFreezeSimplify = flag;} 
    bool IsViolentSimplifyAllowed()
    {
        return fIsViolentSimplifyAllowed;   
    }
    virtual int GetMonoSurfaceType()
    {
        return 0;   
    }
    void SetInfinite()
    {
        if(IsBrick() || IsHexagon()) fInfinite = true;   
    }
 
 
  protected :
 
    virtual void MinimumCopy(Shape *S); 
 
 
    void SetNot(Shape *aNot)
    {
        if(fNot) fNot -> fNot = nullptr;
        fNot = aNot;
        fNot -> fNot = this;
    }
    void SetNotofNot()
    {
        fNot -> SetNot(this);   
    }
 
    virtual Shape *CreateNewInstance(int sign = 1) = 0; 
 
    vector < Shape_ptr >    fInsideShape; 
    vector < Shape_ptr >    fOriginalInsideShape; 
 
    int     fSign; 
    bool    fInfinite; 
    Shape  *fNot;  
    bool    fMouvement; 
    int     fUniverse; 
    int     fFill; 
    double  fVolume; 
    double  fArea; 
    string  fShapeName; 
    string  fDebugName; 
    double  fVirtualSphereR;
    double  *fVirtualSphereO; 
    Shape_ptr   fCloneShape;
    bool    fMirrorBoundary; 
    bool    fOpenZPlanes; 
    bool    fOpenXYPlanes; 
    bool    fWhiteBoundary; 
    bool    fPeriodicBoundary; 
    string  fTopBottPlaneBoundaryCondition; 
    Shape_ptr   fLinkedPlane;
    bool fIsViolentSimplifyAllowed;
    bool fOutermostShape;   
    bool fFreezeSimplify;   
 
    //_________________________________________________________________________________________________
    //          Related Friend Functions
    //_________________________________________________________________________________________________
 
 
    friend Shape_ptr operator& (Shape_ptr A, Shape_ptr B );
    friend Shape_ptr operator| (Shape_ptr A, Shape_ptr B );
    friend Shape_ptr  &operator>> (Shape_ptr &B, Shape_ptr &A );
};
//_________________________________________________________________________________________________
//          Related Functions
//_________________________________________________________________________________________________
Shape_ptr  &operator&= (Shape_ptr &A, Shape_ptr B );
Shape_ptr  &operator|= (Shape_ptr &A, Shape_ptr B );
 
Shape_ptr operator! (Shape_ptr A);
 
 
#endif