[occt.git] / src / AIS / AIS_Plane.cxx

// Created on: 1995-08-02
// Created by: Arnaud BOUZY/Odile Olivier
// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and / or modify it
// under the terms of the GNU Lesser General Public version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#define GER61351		//GG_171199     Enable to set an object RGB color
//						  instead a restricted object NameOfColor.

#include <AIS_Plane.ixx>

#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_HArray1OfPnt.hxx>

#include <Precision.hxx>
#include <gp_Pnt.hxx>
#include <ElSLib.hxx>

#include <Graphic3d_ArrayOfQuadrangles.hxx>
#include <Graphic3d_Group.hxx>
#include <Prs3d_Drawer.hxx>
#include <Prs3d_LineAspect.hxx>
#include <Prs3d_PlaneAspect.hxx>
#include <Prs3d_DatumAspect.hxx>
#include <Prs3d_ShadingAspect.hxx>
#include <StdPrs_Plane.hxx>
#include <StdPrs_ShadedSurface.hxx>

#include <Geom_Plane.hxx>
#include <GeomAdaptor_Surface.hxx>

#include <Aspect_TypeOfLine.hxx>
#include <Graphic3d_AspectLine3d.hxx>
#include <Graphic3d_Structure.hxx>
#include <Graphic3d_MaterialAspect.hxx>
#include <Graphic3d_AspectFillArea3d.hxx>

#include <DsgPrs_XYZPlanePresentation.hxx>
#include <DsgPrs_ShadedPlanePresentation.hxx>
#include <UnitsAPI.hxx>

#include <SelectBasics_EntityOwner.hxx>
#include <SelectMgr_EntityOwner.hxx>
#include <Select3D_SensitiveFace.hxx>
#include <StdPrs_ShadedShape.hxx>

#include <AIS_Drawer.hxx>

#include <TCollection_AsciiString.hxx>

//=======================================================================
//function : AIS_Plane
//purpose  : 
//=======================================================================
AIS_Plane::AIS_Plane(const Handle(Geom_Plane)& aComponent,
		     const Standard_Boolean aCurrentMode):
myComponent(aComponent),
myCenter(gp_Pnt(0.,0.,0.)),
myCurrentMode(aCurrentMode),
myAutomaticPosition(Standard_True),
myTypeOfPlane(AIS_TOPL_Unknown),
myIsXYZPlane(Standard_False),
myTypeOfSensitivity (Select3D_TOS_BOUNDARY)
{
  InitDrawerAttributes();
}

//=======================================================================
//function : AIS_Plane 
//purpose  : avec une position
//=======================================================================
AIS_Plane::AIS_Plane(const Handle(Geom_Plane)& aComponent,
		     const gp_Pnt& aCenter,
		     const Standard_Boolean aCurrentMode):
myComponent(aComponent),
myCenter(aCenter),
myCurrentMode(aCurrentMode),
myAutomaticPosition(Standard_True),
myTypeOfPlane(AIS_TOPL_Unknown),
myIsXYZPlane(Standard_False),
myTypeOfSensitivity (Select3D_TOS_BOUNDARY)
{
  InitDrawerAttributes();
}

//=======================================================================
//function : AIS_Plane
//purpose  : 
//=======================================================================
AIS_Plane::AIS_Plane(const Handle(Geom_Plane)& aComponent,
			       const gp_Pnt& aCenter,
			       const gp_Pnt& aPmin,
			       const gp_Pnt& aPmax,
		               const Standard_Boolean aCurrentMode):
myComponent(aComponent),
myCenter(aCenter),
myPmin(aPmin),
myPmax(aPmax),
myCurrentMode(aCurrentMode),
myAutomaticPosition(Standard_False),
myTypeOfPlane(AIS_TOPL_Unknown),
myIsXYZPlane(Standard_False),
myTypeOfSensitivity (Select3D_TOS_BOUNDARY)
{
  InitDrawerAttributes();
  SetHilightMode(0);
}

//=======================================================================
//function : AIS_Plane
//purpose  : XYPlane, XZPlane, YZPlane
//=======================================================================
AIS_Plane::AIS_Plane(const Handle(Geom_Axis2Placement)& aComponent,
		     const AIS_TypeOfPlane aPlaneType,
		     const Standard_Boolean aCurrentMode):
myAx2(aComponent),
myCurrentMode(aCurrentMode),
myAutomaticPosition(Standard_True),
myTypeOfPlane(aPlaneType),
myIsXYZPlane(Standard_True),
myTypeOfSensitivity (Select3D_TOS_BOUNDARY)
{
  InitDrawerAttributes();
  ComputeFields();
  SetHilightMode(0);

}


//=======================================================================
//function : SetComponent
//purpose  : 
//=======================================================================

void AIS_Plane::SetComponent(const Handle(Geom_Plane)& aComponent)
{
  myComponent = aComponent;
  myTypeOfPlane = AIS_TOPL_Unknown;
  myIsXYZPlane = Standard_False;
  //myCenter = gp_Pnt(0.,0.,0.);
  myAutomaticPosition = Standard_True;
}

//=======================================================================
//function : Type
//purpose  : 
//=======================================================================

AIS_KindOfInteractive AIS_Plane::Type() const 
{return AIS_KOI_Datum;}


//=======================================================================
//function : Signature
//purpose  : 
//=======================================================================

Standard_Integer AIS_Plane::Signature() const 
{return 7;}


//=======================================================================
//function : Axis2Placement
//purpose  : 
//=======================================================================

Handle(Geom_Axis2Placement) AIS_Plane::Axis2Placement()
{
  Handle(Geom_Axis2Placement) Bid;
  return IsXYZPlane() ? myAx2:Bid;
}
//=======================================================================
//function : SetAxis2Placement
//purpose  : 
//=======================================================================

 void AIS_Plane::SetAxis2Placement(const Handle(Geom_Axis2Placement)& aComponent,
				   const AIS_TypeOfPlane aPlaneType)
{
  myTypeOfPlane = aPlaneType;
  myIsXYZPlane = Standard_True;
  myAx2= aComponent;
  myAutomaticPosition = Standard_True;
  ComputeFields();
}

//=======================================================================
//function : PlaneAttributes
//purpose  : 
//=======================================================================
Standard_Boolean AIS_Plane::PlaneAttributes(Handle(Geom_Plane)& aComponent,
					    gp_Pnt& aCenter,
					    gp_Pnt& aPmin,
					    gp_Pnt& aPmax)
{
  Standard_Boolean aStatus (Standard_False);
  if (!myAutomaticPosition){
    aComponent = myComponent;
    aCenter = myCenter;
    aPmin = myPmin;
    aPmax = myPmax;
    aStatus = Standard_True;
  }
  return aStatus;
}

//=======================================================================
//function : SetPlaneAttributes
//purpose  : 
//=======================================================================
void AIS_Plane::SetPlaneAttributes(const Handle(Geom_Plane)& aComponent,
			      const gp_Pnt& aCenter,
			      const gp_Pnt& aPmin,
			      const gp_Pnt& aPmax)
{
  myAutomaticPosition = Standard_False;
  myComponent = aComponent;
  myCenter = aCenter;
  myPmin = aPmin;
  myPmax = aPmax;
  myTypeOfPlane = AIS_TOPL_Unknown;
  myIsXYZPlane = Standard_False;
}

//=======================================================================
//function : Compute
//purpose  : 
//=======================================================================
void AIS_Plane::Compute(const Handle(PrsMgr_PresentationManager3d)& ,
			const Handle(Prs3d_Presentation)& aPresentation, 
			const Standard_Integer aMode)
{
  aPresentation->Clear();

  ComputeFields();
  aPresentation->SetInfiniteState(myInfiniteState);
  myDrawer->PlaneAspect()->EdgesAspect()->SetWidth(myCurrentMode == 0? 1 : 3);

  switch (aMode)
  {
    case 0:
    {
      if (!myIsXYZPlane)
      {
        ComputeFrame();
        const Handle(Geom_Plane)& pl = myComponent;
        const Handle(Geom_Plane)& thegoodpl = Handle(Geom_Plane)::DownCast(pl->Translated(pl->Location(),myCenter));
        GeomAdaptor_Surface surf(thegoodpl);
        StdPrs_Plane::Add(aPresentation,surf,myDrawer);
      }
      else
        DsgPrs_XYZPlanePresentation::Add(aPresentation,myDrawer,myCenter,myPmin,myPmax);
      break;
    }
    case 1:
    {
      if (!myIsXYZPlane)
      {
        ComputeFrame();
        Handle(Prs3d_PlaneAspect) theaspect = myDrawer->PlaneAspect();
        Handle(Graphic3d_Group) TheGroup = Prs3d_Root::CurrentGroup(aPresentation);
        TheGroup->SetPrimitivesAspect(myDrawer->ShadingAspect()->Aspect());
        gp_Pnt p1;
        const Standard_Real Xmax = 0.5*Standard_Real(theaspect->PlaneXLength());
        const Standard_Real Ymax = 0.5*Standard_Real(theaspect->PlaneYLength());

        Handle(Graphic3d_ArrayOfQuadrangles) aQuads = new Graphic3d_ArrayOfQuadrangles(4);

        myComponent->D0(-Xmax,Ymax,p1);
        aQuads->AddVertex(p1);
        myComponent->D0(Xmax,Ymax,p1);
        aQuads->AddVertex(p1);
        myComponent->D0(Xmax,-Ymax,p1);
        aQuads->AddVertex(p1);
        myComponent->D0(-Xmax,-Ymax,p1);
        aQuads->AddVertex(p1);

        TheGroup->AddPrimitiveArray(aQuads);
      }
      else
        DsgPrs_ShadedPlanePresentation::Add(aPresentation,myDrawer,myCenter,myPmin,myPmax);
      break;
    }
  }
}

void AIS_Plane::Compute(const Handle_Prs3d_Projector& aProjector, const Handle_Geom_Transformation& aTransformation, const Handle_Prs3d_Presentation& aPresentation)
{
  PrsMgr_PresentableObject::Compute(aProjector, aTransformation, aPresentation);
}

//=======================================================================
//function : ComputeSelection
//purpose  : 
//=======================================================================
void AIS_Plane::ComputeSelection(const Handle(SelectMgr_Selection)& aSelection,
				    const Standard_Integer)
{
  aSelection->Clear();
  Handle(SelectMgr_EntityOwner) eown = new SelectMgr_EntityOwner(this,10);
  Handle(Select3D_SensitiveFace) sfac;

  if (!myIsXYZPlane){

    Handle(TColgp_HArray1OfPnt) harr = new TColgp_HArray1OfPnt(1,5);
    TColgp_Array1OfPnt& arr = harr->ChangeArray1();
    Standard_Real lx = myDrawer->PlaneAspect()->PlaneXLength()/2.;
    Standard_Real ly = myDrawer->PlaneAspect()->PlaneYLength()/2.;
    const Handle(Geom_Plane)& pl = myComponent;
    const Handle(Geom_Plane)& thegoodpl = Handle(Geom_Plane)::DownCast(pl->Translated(pl->Location(),myCenter));
    
    thegoodpl->D0(lx,ly,arr(1));
    thegoodpl->D0(lx,-ly,arr(2));
    thegoodpl->D0(-lx,-ly,arr(3));
    thegoodpl->D0(-lx,ly,arr(4));
    arr(5) = arr(1);
    sfac = new Select3D_SensitiveFace(eown,harr,myTypeOfSensitivity);

  }
  else {
    Handle(TColgp_HArray1OfPnt) harr1 = new TColgp_HArray1OfPnt(1,4);
    TColgp_Array1OfPnt& arr1 = harr1->ChangeArray1();
    
    arr1(1) = myCenter;
    arr1(2) = myPmin;
    arr1(3) = myPmax;
    arr1(4) = myCenter;
    sfac = new Select3D_SensitiveFace(eown,harr1,myTypeOfSensitivity);

  }
    aSelection->Add(sfac);
}


//=======================================================================
//function : SetSize
//purpose  : 
//=======================================================================
void AIS_Plane::SetSize(const Standard_Real aLength)
{
  SetSize(aLength,aLength);
}

void AIS_Plane::SetSize(const Standard_Real aXLength,
			const Standard_Real aYLength)
{
  //if the plane already has a proper color or size, 
  //there is already a specific PlaneAspect and DatumAspect 
    
  Handle(Prs3d_PlaneAspect) PA; 
  Handle(Prs3d_DatumAspect) DA;

  PA = myDrawer->PlaneAspect();
  DA = myDrawer->DatumAspect();

  Standard_Boolean yenavaitPA(Standard_True),yenavaitDA(Standard_True);
  if(myDrawer->Link()->PlaneAspect() == PA){
    yenavaitPA = Standard_False;
    PA = new Prs3d_PlaneAspect();}
  if(myDrawer->Link()->DatumAspect() == DA){
    yenavaitDA = Standard_False;
    DA = new Prs3d_DatumAspect();
  }
  
  PA->SetPlaneLength(aXLength,aYLength);
  DA->SetAxisLength(aXLength,aYLength,aXLength);
  
  if(!yenavaitPA)
    myDrawer->SetPlaneAspect(PA);
  if(!yenavaitDA)
    myDrawer->SetDatumAspect(DA);
  
  
  myHasOwnSize = Standard_True;
  Update();
  UpdateSelection();
}


//=======================================================================
//function : UnsetSize
//purpose  : If there is a color, the size is restaured from the drawer of the context...
//=======================================================================
void AIS_Plane::UnsetSize()
{
  
  if(!myHasOwnSize) return;
  if(!hasOwnColor){
    myDrawer->PlaneAspect().Nullify();
    myDrawer->DatumAspect().Nullify();
  }
  else{
    const Handle(Prs3d_PlaneAspect)& PA = myDrawer->Link()->PlaneAspect();
    const Handle(Prs3d_DatumAspect)& DA = myDrawer->Link()->DatumAspect();

    myDrawer->PlaneAspect()->SetPlaneLength(PA->PlaneXLength(),PA->PlaneYLength());
    myDrawer->DatumAspect()->SetAxisLength(DA->FirstAxisLength(),
					   DA->SecondAxisLength(),
					   DA->ThirdAxisLength());
  }
  
  myHasOwnSize = Standard_False;
  Update();
  UpdateSelection();

}

//=======================================================================
//function : Size
//purpose  : 
//=======================================================================

Standard_Boolean AIS_Plane::Size(Standard_Real& X,Standard_Real& Y) const 
{
  X = myDrawer->PlaneAspect()->PlaneXLength();
  Y = myDrawer->PlaneAspect()->PlaneYLength();
  return Abs(X-Y)<=Precision::Confusion();
}


//=======================================================================
//function : SetColor
//purpose  : 
//=======================================================================


void AIS_Plane::SetColor(const Quantity_NameOfColor aCol)
#ifdef GER61351
{
  SetColor(Quantity_Color(aCol));
}

void AIS_Plane::SetColor(const Quantity_Color &aCol)
#endif
{
  // if the plane already has its proper size, there is an already created planeaspect 
//  Standard_Boolean yenadeja = hasOwnColor || myHasOwnSize;
  Handle(Prs3d_PlaneAspect) PA; 
  Handle(Prs3d_DatumAspect) DA;

  PA = myDrawer->PlaneAspect();
  DA = myDrawer->DatumAspect();

  Standard_Boolean yenavaitPA(Standard_True),yenavaitDA(Standard_True);
  if(myDrawer->Link()->PlaneAspect() == PA){
    yenavaitPA = Standard_False;
    PA = new Prs3d_PlaneAspect();}
  if(myDrawer->Link()->DatumAspect() == DA){
    yenavaitDA = Standard_False;
    DA = new Prs3d_DatumAspect();
  }
  
  PA->EdgesAspect()->SetColor(aCol);
  DA->FirstAxisAspect()->SetColor(aCol);
  DA->SecondAxisAspect()->SetColor(aCol);
  DA->ThirdAxisAspect()->SetColor(aCol);

  if(!yenavaitPA)
    myDrawer->SetPlaneAspect(PA);
  if(!yenavaitDA)
    myDrawer->SetDatumAspect(DA);

  myDrawer->ShadingAspect()->SetColor(aCol);
  
  hasOwnColor=Standard_True;
  myOwnColor = aCol;
}
//=======================================================================
//function : SetColor
//purpose  : 
//=======================================================================
void AIS_Plane::UnsetColor()
{
  if(!hasOwnColor) return;
  if(!myHasOwnSize){
    myDrawer->PlaneAspect().Nullify();
    myDrawer->DatumAspect().Nullify();
  }
  else{
    const Handle(Prs3d_PlaneAspect)& PA = myDrawer->Link()->PlaneAspect();
//    const Handle(Prs3d_DatumAspect)& DA = myDrawer->Link()->DatumAspect();
    Quantity_Color C;Aspect_TypeOfLine T;Standard_Real W;
    PA->EdgesAspect()->Aspect()->Values(C,T,W);
    Quantity_NameOfColor Col = C.Name();
    myDrawer->PlaneAspect()->EdgesAspect()->SetColor(Col);
    
    myDrawer->DatumAspect()->FirstAxisAspect()->SetColor(Col);
    myDrawer->DatumAspect()->SecondAxisAspect()->SetColor(Col);
    myDrawer->DatumAspect()->ThirdAxisAspect()->SetColor(Col);
  }
 
 
  hasOwnColor=Standard_False;

}

//=======================================================================
//function : ComputeFrame
//purpose  : 
//=======================================================================
void AIS_Plane::ComputeFrame()
{

  const Handle(Geom_Plane)& pl = myComponent;
  Standard_Real U,V;

  if (myAutomaticPosition) {
    ElSLib::Parameters(pl->Pln(),myCenter,U,V);
    pl->D0 (U, V, myCenter);     
  }
  else {
    const Handle(Geom_Plane)& thegoodpl = 
      Handle(Geom_Plane)::DownCast(pl->Translated(pl->Location(),myCenter));
    ElSLib::Parameters(thegoodpl->Pln(),myPmin,U,V);
    
    U = 2.4*Abs(U);
    V = 2.4*Abs(V);
    if (U < 10*Precision::Confusion()) U=0.1;
    if (V < 10*Precision::Confusion()) V=0.1;
    SetSize(U,V);
    myDrawer->PlaneAspect()->SetPlaneLength(U,V);
  }
}

//=======================================================================
//function : Compute
//purpose  : to avoid warning
//=======================================================================
void AIS_Plane::Compute(const Handle(Prs3d_Projector)&, 
			   const Handle(Prs3d_Presentation)&)
{
}

//=======================================================================
//function : ComputeFields
//purpose  : 
//=======================================================================
void AIS_Plane::ComputeFields()
{
  if (myIsXYZPlane){
    Handle (Prs3d_DatumAspect) DA = myDrawer->DatumAspect();

    gp_Pnt Orig = myAx2->Ax2().Location();
    gp_Dir oX = myAx2->Ax2().XDirection();
    gp_Dir oY = myAx2->Ax2().YDirection();
    gp_Dir oZ = myAx2->Ax2().Direction();
    myCenter = Orig;
    Standard_Real xo,yo,zo,x1,y1,z1,x2,y2,z2,x3,y3,z3,x4=0,y4=0,z4=0;
    Standard_Real x5=0,y5=0,z5=0;
    Orig.Coord(xo,yo,zo);
    oX.Coord(x1,y1,z1);
    oY.Coord(x2,y2,z2);
    oZ.Coord(x3,y3,z3);
    Standard_Real DS1 = DA->FirstAxisLength();
    Standard_Real DS2 = DA->SecondAxisLength();
    Standard_Real DS3 = DA->ThirdAxisLength();
//    gp_Pnt aPt2,aPt3;

    switch (myTypeOfPlane) {
    case AIS_TOPL_XYPlane:
      {
	gp_Pln XYP(0,0,1,0);
	myComponent = new Geom_Plane(XYP);
	x4=xo+x1*DS1; y4=yo+y1*DS1; z4=zo+z1*DS1;
	x5=xo+x2*DS2; y5=yo+y2*DS2; z5=zo+z2*DS2;
	break;
      }
    case AIS_TOPL_XZPlane:
      {
	gp_Pln XZP(0,1,0,0);
	myComponent = new Geom_Plane(XZP);
	x4=xo+x1*DS1; y4=yo+y1*DS1; z4=zo+z1*DS1;
	x5=xo+x3*DS3; y5=yo+y3*DS3; z5=zo+z3*DS3;
	break;
      }
    case AIS_TOPL_YZPlane:
      {
	gp_Pln XZP(1,0,0,0);
	myComponent = new Geom_Plane(XZP);
	x4=xo+x2*DS2; y4=yo+y2*DS2; z4=zo+z2*DS2;
	x5=xo+x3*DS3; y5=yo+y3*DS3; z5=zo+z3*DS3;
	break;
      }
    default:
      break;
    }
    myPmin.SetCoord(x4,y4,z4);
    myPmax.SetCoord(x5,y5,z5);
  }

}
//=======================================================================
//function : InitDrawerAttributes
//purpose  : 
//=======================================================================

void AIS_Plane::InitDrawerAttributes()
{

  Handle(Prs3d_ShadingAspect) shasp = new Prs3d_ShadingAspect();
  shasp->SetMaterial(Graphic3d_NOM_PLASTIC);
  shasp->SetColor(Quantity_NOC_GRAY40);
  myDrawer->SetShadingAspect(shasp);
  Handle(Graphic3d_AspectFillArea3d) asf = shasp->Aspect();
  Graphic3d_MaterialAspect asp = asf->FrontMaterial();
  asp.SetTransparency(0.8);
  asf->SetFrontMaterial(asp);
  asf->SetBackMaterial(asp);


}

//=======================================================================
//function : AcceptDisplayMode
//purpose  : 
//=======================================================================

Standard_Boolean  AIS_Plane::
AcceptDisplayMode(const Standard_Integer aMode) const
{return aMode == 0;}


//=======================================================================
//function : SetContext
//purpose  : 
//=======================================================================

void AIS_Plane::SetContext(const Handle(AIS_InteractiveContext)& Ctx)
{
  AIS_InteractiveObject::SetContext(Ctx);
  ComputeFields();

}
Commit	Line	Data
b311480e	1	// Created on: 1995-08-02
	2	// Created by: Arnaud BOUZY/Odile Olivier
	3	// Copyright (c) 1995-1999 Matra Datavision
973c2be1	4	// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e	5	//
973c2be1	6	// This file is part of Open CASCADE Technology software library.
b311480e	7	//
973c2be1	8	// This library is free software; you can redistribute it and / or modify it
	9	// under the terms of the GNU Lesser General Public version 2.1 as published
	10	// by the Free Software Foundation, with special exception defined in the file
	11	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	12	// distribution for complete text of the license and disclaimer of any warranty.
b311480e	13	//
973c2be1	14	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	15	// commercial license or contractual agreement.
7fd59977	16
	17	#define GER61351 //GG_171199 Enable to set an object RGB color
	18	// instead a restricted object NameOfColor.
	19
	20	#include <AIS_Plane.ixx>
	21
	22	#include <TColgp_Array1OfPnt.hxx>
	23	#include <TColgp_HArray1OfPnt.hxx>
	24
	25	#include <Precision.hxx>
	26	#include <gp_Pnt.hxx>
	27	#include <ElSLib.hxx>
	28
b8ddfc2f	29	#include <Graphic3d_ArrayOfQuadrangles.hxx>
7fd59977	30	#include <Graphic3d_Group.hxx>
	31	#include <Prs3d_Drawer.hxx>
	32	#include <Prs3d_LineAspect.hxx>
	33	#include <Prs3d_PlaneAspect.hxx>
	34	#include <Prs3d_DatumAspect.hxx>
	35	#include <Prs3d_ShadingAspect.hxx>
	36	#include <StdPrs_Plane.hxx>
	37	#include <StdPrs_ShadedSurface.hxx>
	38
	39	#include <Geom_Plane.hxx>
	40	#include <GeomAdaptor_Surface.hxx>
	41
	42	#include <Aspect_TypeOfLine.hxx>
	43	#include <Graphic3d_AspectLine3d.hxx>
	44	#include <Graphic3d_Structure.hxx>
	45	#include <Graphic3d_MaterialAspect.hxx>
	46	#include <Graphic3d_AspectFillArea3d.hxx>
	47
	48	#include <DsgPrs_XYZPlanePresentation.hxx>
	49	#include <DsgPrs_ShadedPlanePresentation.hxx>
	50	#include <UnitsAPI.hxx>
	51
	52	#include <SelectBasics_EntityOwner.hxx>
	53	#include <SelectMgr_EntityOwner.hxx>
	54	#include <Select3D_SensitiveFace.hxx>
	55	#include <StdPrs_ShadedShape.hxx>
	56
	57	#include <AIS_Drawer.hxx>
	58
	59	#include <TCollection_AsciiString.hxx>
	60
	61	//=======================================================================
	62	//function : AIS_Plane
	63	//purpose :
	64	//=======================================================================
	65	AIS_Plane::AIS_Plane(const Handle(Geom_Plane)& aComponent,
	66	const Standard_Boolean aCurrentMode):
	67	myComponent(aComponent),
	68	myCenter(gp_Pnt(0.,0.,0.)),
	69	myCurrentMode(aCurrentMode),
	70	myAutomaticPosition(Standard_True),
	71	myTypeOfPlane(AIS_TOPL_Unknown),
9e8804b6	72	myIsXYZPlane(Standard_False),
9e8804b6	73	myTypeOfSensitivity (Select3D_TOS_BOUNDARY)
7fd59977	74	{
	75	InitDrawerAttributes();
	76	}
	77
	78	//=======================================================================
	79	//function : AIS_Plane
	80	//purpose : avec une position
	81	//=======================================================================
	82	AIS_Plane::AIS_Plane(const Handle(Geom_Plane)& aComponent,
	83	const gp_Pnt& aCenter,
	84	const Standard_Boolean aCurrentMode):
	85	myComponent(aComponent),
	86	myCenter(aCenter),
	87	myCurrentMode(aCurrentMode),
	88	myAutomaticPosition(Standard_True),
	89	myTypeOfPlane(AIS_TOPL_Unknown),
9e8804b6	90	myIsXYZPlane(Standard_False),
9e8804b6	91	myTypeOfSensitivity (Select3D_TOS_BOUNDARY)
7fd59977	92	{
	93	InitDrawerAttributes();
	94	}
	95
	96	//=======================================================================
	97	//function : AIS_Plane
	98	//purpose :
	99	//=======================================================================
	100	AIS_Plane::AIS_Plane(const Handle(Geom_Plane)& aComponent,
	101	const gp_Pnt& aCenter,
	102	const gp_Pnt& aPmin,
	103	const gp_Pnt& aPmax,
	104	const Standard_Boolean aCurrentMode):
	105	myComponent(aComponent),
	106	myCenter(aCenter),
	107	myPmin(aPmin),
	108	myPmax(aPmax),
	109	myCurrentMode(aCurrentMode),
	110	myAutomaticPosition(Standard_False),
	111	myTypeOfPlane(AIS_TOPL_Unknown),
9e8804b6	112	myIsXYZPlane(Standard_False),
9e8804b6	113	myTypeOfSensitivity (Select3D_TOS_BOUNDARY)
7fd59977	114	{
	115	InitDrawerAttributes();
	116	SetHilightMode(0);
	117	}
	118
	119	//=======================================================================
	120	//function : AIS_Plane
	121	//purpose : XYPlane, XZPlane, YZPlane
	122	//=======================================================================
	123	AIS_Plane::AIS_Plane(const Handle(Geom_Axis2Placement)& aComponent,
	124	const AIS_TypeOfPlane aPlaneType,
	125	const Standard_Boolean aCurrentMode):
	126	myAx2(aComponent),
	127	myCurrentMode(aCurrentMode),
	128	myAutomaticPosition(Standard_True),
	129	myTypeOfPlane(aPlaneType),
9e8804b6	130	myIsXYZPlane(Standard_True),
9e8804b6	131	myTypeOfSensitivity (Select3D_TOS_BOUNDARY)
7fd59977	132	{
	133	InitDrawerAttributes();
	134	ComputeFields();
	135	SetHilightMode(0);
	136
	137	}
	138
	139
	140	//=======================================================================
	141	//function : SetComponent
	142	//purpose :
	143	//=======================================================================
	144
	145	void AIS_Plane::SetComponent(const Handle(Geom_Plane)& aComponent)
	146	{
	147	myComponent = aComponent;
	148	myTypeOfPlane = AIS_TOPL_Unknown;
	149	myIsXYZPlane = Standard_False;
	150	//myCenter = gp_Pnt(0.,0.,0.);
	151	myAutomaticPosition = Standard_True;
	152	}
	153
	154	//=======================================================================
	155	//function : Type
	156	//purpose :
	157	//=======================================================================
	158
	159	AIS_KindOfInteractive AIS_Plane::Type() const
	160	{return AIS_KOI_Datum;}
	161
	162
	163	//=======================================================================
	164	//function : Signature
	165	//purpose :
	166	//=======================================================================
	167
	168	Standard_Integer AIS_Plane::Signature() const
	169	{return 7;}
	170
	171
	172	//=======================================================================
	173	//function : Axis2Placement
	174	//purpose :
	175	//=======================================================================
	176
	177	Handle(Geom_Axis2Placement) AIS_Plane::Axis2Placement()
	178	{
	179	Handle(Geom_Axis2Placement) Bid;
	180	return IsXYZPlane() ? myAx2:Bid;
	181	}
	182	//=======================================================================
	183	//function : SetAxis2Placement
	184	//purpose :
	185	//=======================================================================
	186
	187	void AIS_Plane::SetAxis2Placement(const Handle(Geom_Axis2Placement)& aComponent,
	188	const AIS_TypeOfPlane aPlaneType)
	189	{
	190	myTypeOfPlane = aPlaneType;
	191	myIsXYZPlane = Standard_True;
	192	myAx2= aComponent;
	193	myAutomaticPosition = Standard_True;
	194	ComputeFields();
	195	}
196
197	//=======================================================================
198	//function : PlaneAttributes
199	//purpose :
200	//=======================================================================
201	Standard_Boolean AIS_Plane::PlaneAttributes(Handle(Geom_Plane)& aComponent,
202	gp_Pnt& aCenter,
203	gp_Pnt& aPmin,
204	gp_Pnt& aPmax)
205	{
206	Standard_Boolean aStatus (Standard_False);
207	if (!myAutomaticPosition){
208	aComponent = myComponent;
209	aCenter = myCenter;
210	aPmin = myPmin;
211	aPmax = myPmax;
212	aStatus = Standard_True;
213	}
214	return aStatus;
215	}
216
217	//=======================================================================
218	//function : SetPlaneAttributes
219	//purpose :
220	//=======================================================================
221	void AIS_Plane::SetPlaneAttributes(const Handle(Geom_Plane)& aComponent,
222	const gp_Pnt& aCenter,
223	const gp_Pnt& aPmin,
224	const gp_Pnt& aPmax)
225	{
226	myAutomaticPosition = Standard_False;
227	myComponent = aComponent;
228	myCenter = aCenter;
229	myPmin = aPmin;
230	myPmax = aPmax;
231	myTypeOfPlane = AIS_TOPL_Unknown;
232	myIsXYZPlane = Standard_False;
233	}
234
235	//=======================================================================
236	//function : Compute
237	//purpose :
238	//=======================================================================
239	void AIS_Plane::Compute(const Handle(PrsMgr_PresentationManager3d)& ,
240	const Handle(Prs3d_Presentation)& aPresentation,
241	const Standard_Integer aMode)
242	{
243	aPresentation->Clear();
244
245	ComputeFields();
246	aPresentation->SetInfiniteState(myInfiniteState);
b8ddfc2f	247	myDrawer->PlaneAspect()->EdgesAspect()->SetWidth(myCurrentMode == 0? 1 : 3);
	248
	249	switch (aMode)
	250	{
	251	case 0:
	252	{
	253	if (!myIsXYZPlane)
	254	{
	255	ComputeFrame();
	256	const Handle(Geom_Plane)& pl = myComponent;
	257	const Handle(Geom_Plane)& thegoodpl = Handle(Geom_Plane)::DownCast(pl->Translated(pl->Location(),myCenter));
	258	GeomAdaptor_Surface surf(thegoodpl);
	259	StdPrs_Plane::Add(aPresentation,surf,myDrawer);
	260	}
	261	else
	262	DsgPrs_XYZPlanePresentation::Add(aPresentation,myDrawer,myCenter,myPmin,myPmax);
	263	break;
7fd59977	264	}
b8ddfc2f	265	case 1:
	266	{
	267	if (!myIsXYZPlane)
	268	{
	269	ComputeFrame();
	270	Handle(Prs3d_PlaneAspect) theaspect = myDrawer->PlaneAspect();
	271	Handle(Graphic3d_Group) TheGroup = Prs3d_Root::CurrentGroup(aPresentation);
	272	TheGroup->SetPrimitivesAspect(myDrawer->ShadingAspect()->Aspect());
	273	gp_Pnt p1;
	274	const Standard_Real Xmax = 0.5*Standard_Real(theaspect->PlaneXLength());
	275	const Standard_Real Ymax = 0.5*Standard_Real(theaspect->PlaneYLength());
	276
	277	Handle(Graphic3d_ArrayOfQuadrangles) aQuads = new Graphic3d_ArrayOfQuadrangles(4);
	278
	279	myComponent->D0(-Xmax,Ymax,p1);
	280	aQuads->AddVertex(p1);
	281	myComponent->D0(Xmax,Ymax,p1);
	282	aQuads->AddVertex(p1);
	283	myComponent->D0(Xmax,-Ymax,p1);
	284	aQuads->AddVertex(p1);
	285	myComponent->D0(-Xmax,-Ymax,p1);
	286	aQuads->AddVertex(p1);
	287
	288	TheGroup->AddPrimitiveArray(aQuads);
7fd59977	289	}
b8ddfc2f	290	else
	291	DsgPrs_ShadedPlanePresentation::Add(aPresentation,myDrawer,myCenter,myPmin,myPmax);
	292	break;
7fd59977	293	}
7fd59977	294	}
7fd59977	295	}
	296
	297	void AIS_Plane::Compute(const Handle_Prs3d_Projector& aProjector, const Handle_Geom_Transformation& aTransformation, const Handle_Prs3d_Presentation& aPresentation)
	298	{
b8ddfc2f	299	PrsMgr_PresentableObject::Compute(aProjector, aTransformation, aPresentation);
7fd59977	300	}
	301
	302	//=======================================================================
	303	//function : ComputeSelection
	304	//purpose :
	305	//=======================================================================
	306	void AIS_Plane::ComputeSelection(const Handle(SelectMgr_Selection)& aSelection,
	307	const Standard_Integer)
	308	{
	309	aSelection->Clear();
	310	Handle(SelectMgr_EntityOwner) eown = new SelectMgr_EntityOwner(this,10);
	311	Handle(Select3D_SensitiveFace) sfac;
	312
	313	if (!myIsXYZPlane){
	314
	315	Handle(TColgp_HArray1OfPnt) harr = new TColgp_HArray1OfPnt(1,5);
	316	TColgp_Array1OfPnt& arr = harr->ChangeArray1();
	317	Standard_Real lx = myDrawer->PlaneAspect()->PlaneXLength()/2.;
	318	Standard_Real ly = myDrawer->PlaneAspect()->PlaneYLength()/2.;
	319	const Handle(Geom_Plane)& pl = myComponent;
	320	const Handle(Geom_Plane)& thegoodpl = Handle(Geom_Plane)::DownCast(pl->Translated(pl->Location(),myCenter));
	321
	322	thegoodpl->D0(lx,ly,arr(1));
	323	thegoodpl->D0(lx,-ly,arr(2));
	324	thegoodpl->D0(-lx,-ly,arr(3));
	325	thegoodpl->D0(-lx,ly,arr(4));
	326	arr(5) = arr(1);
9e8804b6	327	sfac = new Select3D_SensitiveFace(eown,harr,myTypeOfSensitivity);
7fd59977	328
	329	}
	330	else {
	331	Handle(TColgp_HArray1OfPnt) harr1 = new TColgp_HArray1OfPnt(1,4);
	332	TColgp_Array1OfPnt& arr1 = harr1->ChangeArray1();
	333
	334	arr1(1) = myCenter;
	335	arr1(2) = myPmin;
	336	arr1(3) = myPmax;
	337	arr1(4) = myCenter;
9e8804b6	338	sfac = new Select3D_SensitiveFace(eown,harr1,myTypeOfSensitivity);
7fd59977	339
	340	}
	341	aSelection->Add(sfac);
	342	}
	343
	344
	345
	346
	347	//=======================================================================
	348	//function : SetSize
	349	//purpose :
	350	//=======================================================================
	351	void AIS_Plane::SetSize(const Standard_Real aLength)
	352	{
	353	SetSize(aLength,aLength);
	354	}
	355
	356	void AIS_Plane::SetSize(const Standard_Real aXLength,
	357	const Standard_Real aYLength)
	358	{
81bba717	359	//if the plane already has a proper color or size,
81bba717	360	//there is already a specific PlaneAspect and DatumAspect
7fd59977	361
	362	Handle(Prs3d_PlaneAspect) PA;
	363	Handle(Prs3d_DatumAspect) DA;
	364
	365	PA = myDrawer->PlaneAspect();
	366	DA = myDrawer->DatumAspect();
	367
	368	Standard_Boolean yenavaitPA(Standard_True),yenavaitDA(Standard_True);
	369	if(myDrawer->Link()->PlaneAspect() == PA){
	370	yenavaitPA = Standard_False;
	371	PA = new Prs3d_PlaneAspect();}
	372	if(myDrawer->Link()->DatumAspect() == DA){
	373	yenavaitDA = Standard_False;
	374	DA = new Prs3d_DatumAspect();
	375	}
	376
	377	PA->SetPlaneLength(aXLength,aYLength);
	378	DA->SetAxisLength(aXLength,aYLength,aXLength);
	379
	380	if(!yenavaitPA)
	381	myDrawer->SetPlaneAspect(PA);
	382	if(!yenavaitDA)
	383	myDrawer->SetDatumAspect(DA);
	384
	385
	386	myHasOwnSize = Standard_True;
	387	Update();
	388	UpdateSelection();
	389	}
	390
	391
	392	//=======================================================================
	393	//function : UnsetSize
81bba717	394	//purpose : If there is a color, the size is restaured from the drawer of the context...
7fd59977	395	//=======================================================================
	396	void AIS_Plane::UnsetSize()
	397	{
	398
	399	if(!myHasOwnSize) return;
	400	if(!hasOwnColor){
	401	myDrawer->PlaneAspect().Nullify();
	402	myDrawer->DatumAspect().Nullify();
	403	}
	404	else{
	405	const Handle(Prs3d_PlaneAspect)& PA = myDrawer->Link()->PlaneAspect();
	406	const Handle(Prs3d_DatumAspect)& DA = myDrawer->Link()->DatumAspect();
	407
	408	myDrawer->PlaneAspect()->SetPlaneLength(PA->PlaneXLength(),PA->PlaneYLength());
	409	myDrawer->DatumAspect()->SetAxisLength(DA->FirstAxisLength(),
	410	DA->SecondAxisLength(),
	411	DA->ThirdAxisLength());
	412	}
	413
	414	myHasOwnSize = Standard_False;
	415	Update();
	416	UpdateSelection();
	417
	418	}
	419
	420	//=======================================================================
	421	//function : Size
	422	//purpose :
	423	//=======================================================================
	424
	425	Standard_Boolean AIS_Plane::Size(Standard_Real& X,Standard_Real& Y) const
	426	{
	427	X = myDrawer->PlaneAspect()->PlaneXLength();
	428	Y = myDrawer->PlaneAspect()->PlaneYLength();
	429	return Abs(X-Y)<=Precision::Confusion();
	430	}
	431
	432
	433	//=======================================================================
	434	//function : SetColor
	435	//purpose :
	436	//=======================================================================
	437
	438
	439	void AIS_Plane::SetColor(const Quantity_NameOfColor aCol)
	440	#ifdef GER61351
	441	{
	442	SetColor(Quantity_Color(aCol));
	443	}
	444
	445	void AIS_Plane::SetColor(const Quantity_Color &aCol)
	446	#endif
	447	{
81bba717	448	// if the plane already has its proper size, there is an already created planeaspect
7fd59977	449	// Standard_Boolean yenadeja = hasOwnColor \|\| myHasOwnSize;
	450	Handle(Prs3d_PlaneAspect) PA;
	451	Handle(Prs3d_DatumAspect) DA;
	452
	453	PA = myDrawer->PlaneAspect();
	454	DA = myDrawer->DatumAspect();
	455
	456	Standard_Boolean yenavaitPA(Standard_True),yenavaitDA(Standard_True);
	457	if(myDrawer->Link()->PlaneAspect() == PA){
	458	yenavaitPA = Standard_False;
	459	PA = new Prs3d_PlaneAspect();}
	460	if(myDrawer->Link()->DatumAspect() == DA){
	461	yenavaitDA = Standard_False;
	462	DA = new Prs3d_DatumAspect();
	463	}
	464
	465	PA->EdgesAspect()->SetColor(aCol);
	466	DA->FirstAxisAspect()->SetColor(aCol);
	467	DA->SecondAxisAspect()->SetColor(aCol);
	468	DA->ThirdAxisAspect()->SetColor(aCol);
	469
	470	if(!yenavaitPA)
	471	myDrawer->SetPlaneAspect(PA);
	472	if(!yenavaitDA)
	473	myDrawer->SetDatumAspect(DA);
	474
	475	myDrawer->ShadingAspect()->SetColor(aCol);
	476
	477	hasOwnColor=Standard_True;
	478	myOwnColor = aCol;
	479	}
	480	//=======================================================================
	481	//function : SetColor
	482	//purpose :
	483	//=======================================================================
	484	void AIS_Plane::UnsetColor()
	485	{
	486	if(!hasOwnColor) return;
	487	if(!myHasOwnSize){
	488	myDrawer->PlaneAspect().Nullify();
	489	myDrawer->DatumAspect().Nullify();
	490	}
	491	else{
	492	const Handle(Prs3d_PlaneAspect)& PA = myDrawer->Link()->PlaneAspect();
	493	// const Handle(Prs3d_DatumAspect)& DA = myDrawer->Link()->DatumAspect();
	494	Quantity_Color C;Aspect_TypeOfLine T;Standard_Real W;
	495	PA->EdgesAspect()->Aspect()->Values(C,T,W);
	496	Quantity_NameOfColor Col = C.Name();
	497	myDrawer->PlaneAspect()->EdgesAspect()->SetColor(Col);
	498
	499	myDrawer->DatumAspect()->FirstAxisAspect()->SetColor(Col);
	500	myDrawer->DatumAspect()->SecondAxisAspect()->SetColor(Col);
	501	myDrawer->DatumAspect()->ThirdAxisAspect()->SetColor(Col);
	502	}
	503
	504
	505	hasOwnColor=Standard_False;
	506
	507	}
	508
	509	//=======================================================================
	510	//function : ComputeFrame
	511	//purpose :
	512	//=======================================================================
513	void AIS_Plane::ComputeFrame()
514	{
515
516	const Handle(Geom_Plane)& pl = myComponent;
517	Standard_Real U,V;
518
519	if (myAutomaticPosition) {
520	ElSLib::Parameters(pl->Pln(),myCenter,U,V);
521	pl->D0 (U, V, myCenter);
522	}
523	else {
524	const Handle(Geom_Plane)& thegoodpl =
525	Handle(Geom_Plane)::DownCast(pl->Translated(pl->Location(),myCenter));
526	ElSLib::Parameters(thegoodpl->Pln(),myPmin,U,V);
527
528	U = 2.4*Abs(U);
529	V = 2.4*Abs(V);
530	if (U < 10*Precision::Confusion()) U=0.1;
531	if (V < 10*Precision::Confusion()) V=0.1;
532	SetSize(U,V);
533	myDrawer->PlaneAspect()->SetPlaneLength(U,V);
534	}
535	}
536
537	//=======================================================================
7fd59977	538	//function : Compute
	539	//purpose : to avoid warning
	540	//=======================================================================
	541	void AIS_Plane::Compute(const Handle(Prs3d_Projector)&,
	542	const Handle(Prs3d_Presentation)&)
	543	{
	544	}
	545
	546	//=======================================================================
	547	//function : ComputeFields
	548	//purpose :
	549	//=======================================================================
	550	void AIS_Plane::ComputeFields()
	551	{
	552	if (myIsXYZPlane){
	553	Handle (Prs3d_DatumAspect) DA = myDrawer->DatumAspect();
	554
	555	gp_Pnt Orig = myAx2->Ax2().Location();
	556	gp_Dir oX = myAx2->Ax2().XDirection();
	557	gp_Dir oY = myAx2->Ax2().YDirection();
	558	gp_Dir oZ = myAx2->Ax2().Direction();
	559	myCenter = Orig;
	560	Standard_Real xo,yo,zo,x1,y1,z1,x2,y2,z2,x3,y3,z3,x4=0,y4=0,z4=0;
	561	Standard_Real x5=0,y5=0,z5=0;
	562	Orig.Coord(xo,yo,zo);
	563	oX.Coord(x1,y1,z1);
	564	oY.Coord(x2,y2,z2);
	565	oZ.Coord(x3,y3,z3);
	566	Standard_Real DS1 = DA->FirstAxisLength();
	567	Standard_Real DS2 = DA->SecondAxisLength();
	568	Standard_Real DS3 = DA->ThirdAxisLength();
	569	// gp_Pnt aPt2,aPt3;
	570
	571	switch (myTypeOfPlane) {
	572	case AIS_TOPL_XYPlane:
	573	{
	574	gp_Pln XYP(0,0,1,0);
	575	myComponent = new Geom_Plane(XYP);
	576	x4=xo+x1DS1; y4=yo+y1DS1; z4=zo+z1*DS1;
	577	x5=xo+x2DS2; y5=yo+y2DS2; z5=zo+z2*DS2;
	578	break;
	579	}
	580	case AIS_TOPL_XZPlane:
	581	{
	582	gp_Pln XZP(0,1,0,0);
	583	myComponent = new Geom_Plane(XZP);
	584	x4=xo+x1DS1; y4=yo+y1DS1; z4=zo+z1*DS1;
	585	x5=xo+x3DS3; y5=yo+y3DS3; z5=zo+z3*DS3;
	586	break;
	587	}
	588	case AIS_TOPL_YZPlane:
	589	{
	590	gp_Pln XZP(1,0,0,0);
	591	myComponent = new Geom_Plane(XZP);
	592	x4=xo+x2DS2; y4=yo+y2DS2; z4=zo+z2*DS2;
	593	x5=xo+x3DS3; y5=yo+y3DS3; z5=zo+z3*DS3;
	594	break;
	595	}
	596	default:
	597	break;
	598	}
	599	myPmin.SetCoord(x4,y4,z4);
	600	myPmax.SetCoord(x5,y5,z5);
	601	}
602
603	}
604	//=======================================================================
605	//function : InitDrawerAttributes
606	//purpose :
607	//=======================================================================
608
609	void AIS_Plane::InitDrawerAttributes()
610	{
611
612	Handle(Prs3d_ShadingAspect) shasp = new Prs3d_ShadingAspect();
613	shasp->SetMaterial(Graphic3d_NOM_PLASTIC);
614	shasp->SetColor(Quantity_NOC_GRAY40);
615	myDrawer->SetShadingAspect(shasp);
616	Handle(Graphic3d_AspectFillArea3d) asf = shasp->Aspect();
617	Graphic3d_MaterialAspect asp = asf->FrontMaterial();
618	asp.SetTransparency(0.8);
619	asf->SetFrontMaterial(asp);
620	asf->SetBackMaterial(asp);
621
622
623	}
624
625	//=======================================================================
626	//function : AcceptDisplayMode
627	//purpose :
628	//=======================================================================
629
630	Standard_Boolean AIS_Plane::
631	AcceptDisplayMode(const Standard_Integer aMode) const
632	{return aMode == 0;}
633
634
635	//=======================================================================
636	//function : SetContext
637	//purpose :
638	//=======================================================================
639
640	void AIS_Plane::SetContext(const Handle(AIS_InteractiveContext)& Ctx)
641	{
642	AIS_InteractiveObject::SetContext(Ctx);
643	ComputeFields();
644
645	}