mirror of
https://git.dev.opencascade.org/repos/occt.git
synced 2025-04-05 18:16:23 +03:00
d5f74e42d6
License statement text corrected; compiler warnings caused by Bison 2.41 disabled for MSVC; a few other compiler warnings on 54-bit Windows eliminated by appropriate type cast Wrong license statements corrected in several files. Copyright and license statements added in XSD and GLSL files. Copyright year updated in some files. Obsolete documentation files removed from DrawResources.
443 lines
10 KiB
Plaintext
443 lines
10 KiB
Plaintext
// Created on: 1993-02-05
|
|
// Created by: Jacques GOUSSARD
|
|
// Copyright (c) 1993-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 License 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 Tolpetit 1.e-10 // pour dist au carre
|
|
#include <ElSLib.hxx>
|
|
|
|
|
|
#include <TColStd_SequenceOfInteger.hxx>
|
|
|
|
static Standard_Boolean FindLine(Contap_TheLine& Line,
|
|
const TheSurface& Surf,
|
|
const gp_Pnt2d& Pt2d,
|
|
gp_Pnt& Ptref,
|
|
Standard_Real& Paramin,
|
|
gp_Vec& Tgmin,
|
|
gp_Vec& Norm)
|
|
{
|
|
// Standard_Integer i;
|
|
gp_Pnt pt,ptmin;
|
|
gp_Vec tg;
|
|
Standard_Real para,dist;
|
|
Standard_Real dismin = RealLast();
|
|
|
|
Contap_TheSurfProps::Normale(Surf,Pt2d.X(),Pt2d.Y(),Ptref,Norm);
|
|
|
|
if (Line.TypeContour() == Contap_Lin) {
|
|
gp_Lin lin(Line.Line());
|
|
para = ElCLib::Parameter(lin,Ptref);
|
|
ElCLib::D1(para,lin,pt,tg);
|
|
dist = pt.Distance(Ptref) + Abs(Norm.Dot(lin.Direction()));
|
|
}
|
|
else { // Contap__Circle
|
|
gp_Circ cir(Line.Circle());
|
|
para = ElCLib::Parameter(cir,Ptref);
|
|
ElCLib::D1(para,cir,pt,tg);
|
|
dist = pt.Distance(Ptref)+Abs(Norm.Dot(tg/cir.Radius()));
|
|
}
|
|
if (dist < dismin) {
|
|
dismin = dist;
|
|
Paramin = para;
|
|
ptmin = pt;
|
|
Tgmin = tg;
|
|
}
|
|
if (ptmin.SquareDistance(Ptref) <= Tolpetit) {
|
|
return Standard_True;
|
|
}
|
|
else {
|
|
return Standard_False;
|
|
}
|
|
}
|
|
|
|
|
|
static void PutPointsOnLine (const Contap_TheSearch& solrst,
|
|
const TheSurface& Surf,
|
|
Contap_TheSequenceOfLine& slin)
|
|
|
|
{
|
|
Standard_Integer i,l;//,index;
|
|
Standard_Integer NbPoints = solrst.NbPoints();
|
|
|
|
Standard_Real theparam;
|
|
|
|
IntSurf_Transition TLine,TArc;
|
|
Standard_Boolean goon;
|
|
|
|
gp_Pnt2d pt2d;
|
|
gp_Vec2d d2d;
|
|
|
|
gp_Pnt ptonsurf;
|
|
gp_Vec vectg,normale,tgtrst;
|
|
Standard_Real paramlin = 0.0;
|
|
|
|
|
|
Standard_Integer nbLin = slin.Length();
|
|
for(l=1;l<=nbLin;l++) {
|
|
Contap_TheLine& Line=slin.ChangeValue(l);
|
|
for (i=1; i<= NbPoints; i++) {
|
|
|
|
const Contap_ThePathPointOfTheSearch& PStart = solrst.Point(i);
|
|
const TheArc& thearc = PStart.Arc();
|
|
theparam = PStart.Parameter();
|
|
|
|
TheArcTool::D1(thearc,theparam,pt2d,d2d);
|
|
goon = FindLine(Line,Surf,pt2d,ptonsurf,paramlin,vectg,normale);
|
|
|
|
Contap_ThePoint PPoint;
|
|
|
|
if (goon) {
|
|
gp_Vec d1u,d1v;
|
|
gp_Pnt bidpt;
|
|
TheSurfaceTool::D1(Surf,pt2d.X(),pt2d.Y(),bidpt,d1u,d1v);
|
|
PPoint.SetValue(ptonsurf,pt2d.X(),pt2d.Y());
|
|
if (normale.Magnitude() < RealEpsilon()) {
|
|
TLine.SetValue();
|
|
TArc.SetValue();
|
|
}
|
|
else {
|
|
// Petit test qui devrait permettre de bien traiter les pointes
|
|
// des cones, et les sommets d`une sphere. Il faudrait peut-etre
|
|
// rajouter une methode dans SurfProps
|
|
|
|
if (Abs(d2d.Y()) <= Precision::Confusion()) {
|
|
tgtrst = d1v.Crossed(normale);
|
|
if(d2d.X() < 0.0)
|
|
tgtrst.Reverse();
|
|
}
|
|
else {
|
|
tgtrst.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);
|
|
}
|
|
IntSurf::MakeTransition(vectg,tgtrst,normale,TLine,TArc);
|
|
}
|
|
|
|
PPoint.SetArc(thearc,theparam, TLine, TArc);
|
|
PPoint.SetParameter(paramlin);
|
|
if (!PStart.IsNew()) {
|
|
PPoint.SetVertex(PStart.Vertex());
|
|
}
|
|
Line.Add(PPoint);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------------
|
|
//-- Orientation des contours Apparents quand ceux-ci sont des lignes ou des cercles
|
|
//-- On prend un point de la ligne ou du cercle ---> P
|
|
//-- On projete ce point sur la surface P ---> u,v
|
|
//-- et on evalue la transition au point u,v
|
|
//----------------------------------------------------------------------------------
|
|
|
|
IntSurf_TypeTrans ComputeTransitionOngpLine
|
|
(Contap_TheSurfFunction& SFunc,
|
|
const gp_Lin& L)
|
|
{
|
|
const TheSurface& Surf=SFunc.Surface();
|
|
GeomAbs_SurfaceType typS = TheSurfaceTool::GetType(Surf);
|
|
gp_Pnt P;
|
|
gp_Vec T;
|
|
ElCLib::D1(0.0,L,P,T);
|
|
Standard_Real u = 0.,v = 0.;
|
|
switch (typS) {
|
|
case GeomAbs_Cylinder: {
|
|
ElSLib::Parameters(TheSurfaceTool::Cylinder(Surf),P,u,v);
|
|
break;
|
|
}
|
|
case GeomAbs_Cone: {
|
|
ElSLib::Parameters(TheSurfaceTool::Cone(Surf),P,u,v);
|
|
break;
|
|
}
|
|
case GeomAbs_Sphere: {
|
|
ElSLib::Parameters(TheSurfaceTool::Sphere(Surf),P,u,v);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return(ComputeTransitionOnLine(SFunc,u,v,T));
|
|
}
|
|
|
|
|
|
IntSurf_TypeTrans ComputeTransitionOngpCircle
|
|
(Contap_TheSurfFunction& SFunc,
|
|
const gp_Circ& C)
|
|
{
|
|
const TheSurface& Surf=SFunc.Surface();
|
|
GeomAbs_SurfaceType typS = TheSurfaceTool::GetType(Surf);
|
|
gp_Pnt P;
|
|
gp_Vec T;
|
|
ElCLib::D1(0.0,C,P,T);
|
|
Standard_Real u = 0.,v = 0.;
|
|
switch (typS) {
|
|
case GeomAbs_Cylinder: {
|
|
ElSLib::Parameters(TheSurfaceTool::Cylinder(Surf),P,u,v);
|
|
break;
|
|
}
|
|
case GeomAbs_Cone: {
|
|
ElSLib::Parameters(TheSurfaceTool::Cone(Surf),P,u,v);
|
|
break;
|
|
}
|
|
case GeomAbs_Sphere: {
|
|
ElSLib::Parameters(TheSurfaceTool::Sphere(Surf),P,u,v);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return(ComputeTransitionOnLine(SFunc,u,v,T));
|
|
}
|
|
|
|
|
|
void Contap_ContourGen::PerformAna(const Handle(TheTopolTool)& Domain)
|
|
{
|
|
|
|
done = Standard_False;
|
|
slin.Clear();
|
|
|
|
Standard_Real TolArc = 1.e-5;
|
|
|
|
Standard_Integer nbCont, nbPointRst, i;
|
|
//gp_Circ cirsol;
|
|
//gp_Lin linsol;
|
|
Contap_ContAna contana;
|
|
Contap_TheLine theline;
|
|
const TheSurface& Surf = mySFunc.Surface();
|
|
Contap_TFunction TypeFunc(mySFunc.FunctionType());
|
|
Standard_Boolean PerformSolRst = Standard_True;
|
|
|
|
GeomAbs_SurfaceType typS = TheSurfaceTool::GetType(Surf);
|
|
|
|
switch (typS) {
|
|
case GeomAbs_Plane:
|
|
{
|
|
gp_Pln pl(TheSurfaceTool::Plane(Surf));
|
|
switch (TypeFunc) {
|
|
case Contap_ContourStd:
|
|
{
|
|
gp_Dir Dirpln(pl.Axis().Direction());
|
|
if (Abs(mySFunc.Direction().Dot(Dirpln)) > Precision::Angular()) {
|
|
// Aucun point du plan n`est solution, en particulier aucun point
|
|
// sur restriction.
|
|
PerformSolRst = Standard_False;
|
|
}
|
|
}
|
|
break;
|
|
case Contap_ContourPrs:
|
|
{
|
|
gp_Pnt Eye(mySFunc.Eye());
|
|
if (pl.Distance(Eye) > Precision::Confusion()) {
|
|
// Aucun point du plan n`est solution, en particulier aucun point
|
|
// sur restriction.
|
|
PerformSolRst = Standard_False;
|
|
}
|
|
}
|
|
break;
|
|
case Contap_DraftStd:
|
|
{
|
|
gp_Dir Dirpln(pl.Axis().Direction());
|
|
Standard_Real Sina = Sin(mySFunc.Angle());
|
|
if (Abs(mySFunc.Direction().Dot(Dirpln)+ Sina) > //voir SurfFunction
|
|
Precision::Angular()) {
|
|
|
|
PerformSolRst = Standard_False;
|
|
}
|
|
}
|
|
break;
|
|
case Contap_DraftPrs:
|
|
default:
|
|
{
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case GeomAbs_Sphere:
|
|
{
|
|
switch (TypeFunc) {
|
|
case Contap_ContourStd:
|
|
{
|
|
contana.Perform(TheSurfaceTool::Sphere(Surf),mySFunc.Direction());
|
|
}
|
|
break;
|
|
case Contap_ContourPrs:
|
|
{
|
|
contana.Perform(TheSurfaceTool::Sphere(Surf),mySFunc.Eye());
|
|
}
|
|
break;
|
|
case Contap_DraftStd:
|
|
{
|
|
contana.Perform(TheSurfaceTool::Sphere(Surf),
|
|
mySFunc.Direction(),mySFunc.Angle());
|
|
}
|
|
break;
|
|
case Contap_DraftPrs:
|
|
default:
|
|
{
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case GeomAbs_Cylinder:
|
|
{
|
|
switch (TypeFunc) {
|
|
case Contap_ContourStd:
|
|
{
|
|
contana.Perform(TheSurfaceTool::Cylinder(Surf),mySFunc.Direction());
|
|
}
|
|
break;
|
|
case Contap_ContourPrs:
|
|
{
|
|
contana.Perform(TheSurfaceTool::Cylinder(Surf),mySFunc.Eye());
|
|
}
|
|
break;
|
|
case Contap_DraftStd:
|
|
{
|
|
contana.Perform(TheSurfaceTool::Cylinder(Surf),
|
|
mySFunc.Direction(),mySFunc.Angle());
|
|
}
|
|
break;
|
|
case Contap_DraftPrs:
|
|
default:
|
|
{
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case GeomAbs_Cone:
|
|
{
|
|
switch (TypeFunc) {
|
|
case Contap_ContourStd:
|
|
{
|
|
contana.Perform(TheSurfaceTool::Cone(Surf),mySFunc.Direction());
|
|
}
|
|
break;
|
|
case Contap_ContourPrs:
|
|
{
|
|
contana.Perform(TheSurfaceTool::Cone(Surf),mySFunc.Eye());
|
|
}
|
|
break;
|
|
case Contap_DraftStd:
|
|
{
|
|
contana.Perform(TheSurfaceTool::Cone(Surf),
|
|
mySFunc.Direction(),mySFunc.Angle());
|
|
}
|
|
break;
|
|
case Contap_DraftPrs:
|
|
default:
|
|
{
|
|
}
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (typS != GeomAbs_Plane) {
|
|
|
|
if (!contana.IsDone()) {
|
|
return;
|
|
}
|
|
|
|
nbCont = contana.NbContours();
|
|
|
|
if (contana.NbContours() == 0) {
|
|
done = Standard_True;
|
|
return;
|
|
}
|
|
|
|
GeomAbs_CurveType typL = contana.TypeContour();
|
|
if (typL == GeomAbs_Circle) {
|
|
theline.SetValue(contana.Circle());
|
|
IntSurf_TypeTrans TransCircle;
|
|
TransCircle = ComputeTransitionOngpCircle(mySFunc,contana.Circle());
|
|
theline.SetTransitionOnS(TransCircle);
|
|
slin.Append(theline);
|
|
}
|
|
else if (typL == GeomAbs_Line) {
|
|
for (i=1; i<=nbCont; i++) {
|
|
theline.SetValue(contana.Line(i));
|
|
IntSurf_TypeTrans TransLine;
|
|
TransLine = ComputeTransitionOngpLine(mySFunc,contana.Line(i));
|
|
theline.SetTransitionOnS(TransLine);
|
|
slin.Append(theline);
|
|
theline.Clear();
|
|
}
|
|
|
|
/*
|
|
if (typS == GeomAbs_Cone) {
|
|
Standard_Real u,v;
|
|
gp_Cone thecone(TheSurfaceTool::Cone(Surf));
|
|
ElSLib::Parameters(thecone,thecone.Apex(),u,v);
|
|
Contap_ThePoint vtxapex(thecone.Apex(),u,v);
|
|
vtxapex.SetInternal();
|
|
vtxapex.SetMultiple();
|
|
for (i=1; i<=nbCont i++) {
|
|
slin.ChangeValue(i).Add(vtxapex);
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
}
|
|
|
|
if(PerformSolRst) {
|
|
|
|
solrst.Perform(myAFunc,Domain,TolArc,TolArc);
|
|
if (!solrst.IsDone()) {
|
|
return;
|
|
}
|
|
nbPointRst = solrst.NbPoints();
|
|
|
|
if (nbPointRst != 0) {
|
|
PutPointsOnLine(solrst,Surf,slin);
|
|
}
|
|
|
|
if (solrst.NbSegments() !=0) {
|
|
ProcessSegments(solrst,slin,TolArc,mySFunc,Domain);
|
|
}
|
|
|
|
|
|
//-- lbr
|
|
//Standard_Boolean oneremov;
|
|
Standard_Integer nblinto = slin.Length();
|
|
TColStd_SequenceOfInteger SeqToDestroy;
|
|
|
|
//-- cout<<" Construct Contour_3 nblin = "<<nblinto<<endl;
|
|
for(i=1; i<= nblinto ; i++) {
|
|
//-- cout<<" nbvtx : "<<slin.Value(i).NbVertex()<<endl;
|
|
//--if(slin.Value(i).NbVertex() > 1) {
|
|
if(slin.Value(i).TypeContour() != Contap_Restriction) {
|
|
LineConstructor(slin,Domain,slin.ChangeValue(i),Surf);
|
|
SeqToDestroy.Append(i);
|
|
}
|
|
//-- }
|
|
}
|
|
for(i=SeqToDestroy.Length(); i>=1; i--) {
|
|
slin.Remove(SeqToDestroy.Value(i));
|
|
}
|
|
}
|
|
|
|
done = Standard_True;
|
|
}
|
|
|
|
|
|
|
|
|
|
|