OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-21 10:13:43 +03:00
Code
occt/src/StdPrs/StdPrs_WFSurface.cxx
kgv b8ddfc2f5d 0023634: Eliminate Polyline and Polygon usage in drawers 
Polylines and polygons removed, now everything is based on PrimitiveArrays.
Added use of Graphic3d_ArrayOfSegments, some additional clean up in Graphic3d_Group.
Dead code elimination in AIS and V3d
Corrected compilation errors
Fixed grid presentation
Adding test case correction
2013-01-18 13:36:18 +04:00

305 lines
9.7 KiB
C++
Executable File
Raw Blame History

// Created on: 1995-08-04
// Created by: Modelistation
// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2012 OPEN CASCADE SAS
//
// The content of this file is subject to the Open CASCADE Technology Public
// License Version 6.5 (the "License"). You may not use the content of this file
// except in compliance with the License. Please obtain a copy of the License
// at http://www.opencascade.org and read it completely before using this file.
//
// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
//
// The Original Code and all software distributed under the License is
// distributed on an "AS IS" basis, without warranty of any kind, and the
// Initial Developer hereby disclaims all such warranties, including without
// limitation, any warranties of merchantability, fitness for a particular
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.
#include <StdPrs_WFSurface.ixx>
#include <Graphic3d_Group.hxx>
#include <Graphic3d_ArrayOfPolylines.hxx>
#include <GeomAbs_IsoType.hxx>
#include <Prs3d_IsoAspect.hxx>
#include <Bnd_Box.hxx>
#include <Precision.hxx>
#include <BndLib_AddSurface.hxx>
#include <Adaptor3d_IsoCurve.hxx>
#include <StdPrs_Curve.hxx>
#include <TColgp_SequenceOfPnt.hxx>
#include <Prs3d_NListOfSequenceOfPnt.hxx>
#include <Prs3d_NListIteratorOfListOfSequenceOfPnt.hxx>
static void FindLimits(const Handle(Adaptor3d_HSurface)& surf ,
const Standard_Real aLimit,
Standard_Real& UFirst,
Standard_Real& ULast,
Standard_Real& VFirst,
Standard_Real& VLast)
{
UFirst = surf->FirstUParameter();
ULast = surf->LastUParameter();
VFirst = surf->FirstVParameter();
VLast = surf->LastVParameter();
Standard_Boolean UfirstInf = Precision::IsNegativeInfinite(UFirst);
Standard_Boolean UlastInf = Precision::IsPositiveInfinite(ULast);
Standard_Boolean VfirstInf = Precision::IsNegativeInfinite(VFirst);
Standard_Boolean VlastInf = Precision::IsPositiveInfinite(VLast);
if (UfirstInf || UlastInf) {
gp_Pnt P1,P2;
Standard_Real v;
if (VfirstInf && VlastInf)
v = 0;
else if (VfirstInf)
v = VLast;
else if (VlastInf)
v = VFirst;
else
v = (VFirst + VLast) / 2;
Standard_Real delta = aLimit * 2;
if (UfirstInf && UlastInf) {
do {
delta /= 2;
UFirst = - delta;
ULast = delta;
surf->D0(UFirst,v,P1);
surf->D0(ULast,v,P2);
} while (P1.Distance(P2) > aLimit);
}
else if (UfirstInf) {
surf->D0(ULast,v,P2);
do {
delta /= 2;
UFirst = ULast - delta;
surf->D0(UFirst,v,P1);
} while (P1.Distance(P2) > aLimit);
}
else if (UlastInf) {
surf->D0(UFirst,v,P1);
do {
delta /= 2;
ULast = UFirst + delta;
surf->D0(ULast,v,P2);
} while (P1.Distance(P2) > aLimit);
}
}
if (VfirstInf || VlastInf) {
gp_Pnt P1,P2;
Standard_Real u = (UFirst + ULast) /2 ;
Standard_Real delta = aLimit * 2;
if (VfirstInf && VlastInf) {
do {
delta /= 2;
VFirst = - delta;
VLast = delta;
surf->D0(u,VFirst,P1);
surf->D0(u,VLast,P2);
} while (P1.Distance(P2) > aLimit);
}
else if (VfirstInf) {
surf->D0(u,VLast,P2);
do {
delta /= 2;
VFirst = VLast - delta;
surf->D0(u,VFirst,P1);
} while (P1.Distance(P2) > aLimit);
}
else if (VlastInf) {
surf->D0(u,VFirst,P1);
do {
delta /= 2;
VLast = VFirst + delta;
surf->D0(u,VLast,P2);
} while (P1.Distance(P2) > aLimit);
}
}
}
//=======================================================================
//function : Add
//purpose :
//=======================================================================
void StdPrs_WFSurface::Add (const Handle(Prs3d_Presentation)& aPresentation,
const Handle(Adaptor3d_HSurface)& aSurface,
const Handle(Prs3d_Drawer)& aDrawer)
{
Standard_Real U1, U2, V1, V2;
Standard_Real MaxP = aDrawer->MaximalParameterValue();
FindLimits(aSurface, MaxP, U1, U2, V1, V2);
Prs3d_NListOfSequenceOfPnt freeCurves;
Prs3d_NListOfSequenceOfPnt UIsoCurves;
Prs3d_NListOfSequenceOfPnt VIsoCurves;
TColgp_SequenceOfPnt Pnts;
Standard_Boolean UClosed = aSurface->IsUClosed();
Standard_Boolean VClosed = aSurface->IsVClosed();
Standard_Real TheDeflection;
Aspect_TypeOfDeflection TOD = aDrawer->TypeOfDeflection();
if (TOD == Aspect_TOD_RELATIVE) {
// On calcule la fleche en fonction des min max globaux de la piece:
Bnd_Box Total;
BndLib_AddSurface::Add(aSurface->Surface(),U1, U2, V1, V2, 0.,Total);
Standard_Real m = aDrawer->MaximalChordialDeviation()/
aDrawer->DeviationCoefficient();
Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax;
Total.Get( aXmin, aYmin, aZmin, aXmax, aYmax, aZmax );
if ( ! (Total.IsOpenXmin() || Total.IsOpenXmax() ))
m = Min ( m , Abs (aXmax-aXmin));
if ( ! (Total.IsOpenYmin() || Total.IsOpenYmax() ))
m = Min ( m , Abs (aYmax-aYmin));
if ( ! (Total.IsOpenZmin() || Total.IsOpenZmax() ))
m = Min ( m , Abs (aZmax-aZmin));
TheDeflection = m * aDrawer->DeviationCoefficient();
}
else
TheDeflection = aDrawer->MaximalChordialDeviation();
Adaptor3d_IsoCurve anIso;
anIso.Load(aSurface);
// Trace des frontieres.
// *********************
//
if ( !(UClosed && VClosed) ) {
(Prs3d_Root::CurrentGroup(aPresentation))->SetPrimitivesAspect
(aDrawer->FreeBoundaryAspect()->Aspect());
if ( !UClosed )
{
anIso.Load(GeomAbs_IsoU,U1,V1,V2);
StdPrs_Curve::Add(aPresentation,anIso,TheDeflection, aDrawer, Pnts, Standard_False);
freeCurves.Append(Pnts);
Pnts.Clear();
anIso.Load(GeomAbs_IsoU,U2,V1,V2);
StdPrs_Curve::Add(aPresentation,anIso,TheDeflection, aDrawer, Pnts, Standard_False);
freeCurves.Append(Pnts);
Pnts.Clear();
}
if ( !VClosed )
{
anIso.Load(GeomAbs_IsoV,V1,U1,U2);
StdPrs_Curve::Add(aPresentation,anIso,TheDeflection, aDrawer, Pnts, Standard_False);
freeCurves.Append(Pnts);
Pnts.Clear();
anIso.Load(GeomAbs_IsoV,V2,U1,U2);
StdPrs_Curve::Add(aPresentation,anIso,TheDeflection, aDrawer, Pnts, Standard_False);
freeCurves.Append(Pnts);
Pnts.Clear();
}
}
//
// Trace des isoparametriques.
// ***************************
//
Standard_Integer fin = aDrawer->UIsoAspect()->Number();
if ( fin != 0) {
(Prs3d_Root::CurrentGroup(aPresentation))->SetPrimitivesAspect
(aDrawer->UIsoAspect()->Aspect());
Standard_Real du= UClosed ? (U2-U1)/fin : (U2-U1)/(1+fin);
for (Standard_Integer i=1; i<=fin;i++){
anIso.Load(GeomAbs_IsoU,U1+du*i,V1,V2);
StdPrs_Curve::Add(aPresentation,anIso,TheDeflection, aDrawer, Pnts, Standard_False);
UIsoCurves.Append(Pnts);
Pnts.Clear();
}
}
fin = aDrawer->VIsoAspect()->Number();
if ( fin != 0) {
(Prs3d_Root::CurrentGroup(aPresentation))->SetPrimitivesAspect
(aDrawer->VIsoAspect()->Aspect());
Standard_Real dv= VClosed ?(V2-V1)/fin : (V2-V1)/(1+fin);
for (Standard_Integer i=1; i<=fin;i++){
anIso.Load(GeomAbs_IsoV,V1+dv*i,U1,U2);
StdPrs_Curve::Add(aPresentation,anIso,TheDeflection, aDrawer, Pnts, Standard_False);
VIsoCurves.Append(Pnts);
Pnts.Clear();
}
}
Standard_Integer nbVertices = 0, nbBounds = 0;
//Draw surface via primitive array
if(UIsoCurves.Size() > 0) {
nbBounds = UIsoCurves.Size();
Prs3d_NListIteratorOfListOfSequenceOfPnt It;
for( It.Init(UIsoCurves); It.More(); It.Next())
nbVertices += It.Value().Length();
Handle(Graphic3d_ArrayOfPolylines) UIsoArray =
new Graphic3d_ArrayOfPolylines(nbVertices,nbBounds);
for( It.Init(UIsoCurves); It.More(); It.Next()) {
TColgp_SequenceOfPnt Pnts;
Pnts.Assign(It.Value());
UIsoArray->AddBound(Pnts.Length());
for(int i=1; i<=Pnts.Length(); i++)
UIsoArray->AddVertex(Pnts.Value(i));
}
Handle(Graphic3d_Group) TheGroup = Prs3d_Root::NewGroup(aPresentation);
TheGroup->SetPrimitivesAspect(aDrawer->UIsoAspect()->Aspect());
TheGroup->AddPrimitiveArray(UIsoArray);
}
if(VIsoCurves.Size() > 0) {
nbBounds = VIsoCurves.Size();
Prs3d_NListIteratorOfListOfSequenceOfPnt It;
for( It.Init(VIsoCurves); It.More(); It.Next())
nbVertices += It.Value().Length();
Handle(Graphic3d_ArrayOfPolylines) VIsoArray =
new Graphic3d_ArrayOfPolylines(nbVertices,nbBounds);
for( It.Init(VIsoCurves); It.More(); It.Next()) {
TColgp_SequenceOfPnt Pnts;
Pnts.Assign(It.Value());
VIsoArray->AddBound(Pnts.Length());
for(int i=1; i<=Pnts.Length(); i++)
VIsoArray->AddVertex(Pnts.Value(i));
}
Handle(Graphic3d_Group) TheGroup = Prs3d_Root::NewGroup(aPresentation);
TheGroup->SetPrimitivesAspect(aDrawer->VIsoAspect()->Aspect());
TheGroup->AddPrimitiveArray(VIsoArray);
}
if(freeCurves.Size() > 0) {
nbBounds = freeCurves.Size();
Prs3d_NListIteratorOfListOfSequenceOfPnt It;
for( It.Init(freeCurves); It.More(); It.Next())
nbVertices += It.Value().Length();
Handle(Graphic3d_ArrayOfPolylines) freeArray =
new Graphic3d_ArrayOfPolylines(nbVertices,nbBounds);
for( It.Init(freeCurves); It.More(); It.Next()) {
TColgp_SequenceOfPnt Pnts;
Pnts.Assign(It.Value());
freeArray->AddBound(Pnts.Length());
for(int i=1; i<=Pnts.Length(); i++)
freeArray->AddVertex(Pnts.Value(i));
}
Handle(Graphic3d_Group) TheGroup = Prs3d_Root::NewGroup(aPresentation);
TheGroup->SetPrimitivesAspect(aDrawer->FreeBoundaryAspect()->Aspect());
TheGroup->AddPrimitiveArray(freeArray);
}
}
View Git Blame Copy Permalink