OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-08-24 13:50:49 +03:00
Code Activity

0024708: Convertation of the generic classes to the non-generic. Part 2

Browse Source 
Generic classes from "AppParCurves" package:
    "AppDef_SmoothCriterion", "AppDef_LinearCriteria" and "AppDef_Variational" moved to the corresponding non-generic classes "AppDef_SmoothCriterion", "AppDef_LinearCriteria" and "AppDef_Variational" to "AppDef" package. Also several "*.cxx" files of "AppDef_Variational" class merged to one ".cxx".
Generic class from "IntImp" package:
    "IntImp_ZerCOnSSParFunc" moved to the corresponding non-generic class "IntPatch_CSFunction" to "IntPatch" package.
Next unused generic classes were removed:

- IntCurveSurface_SurfaceTool
- Intf_InterferencePolygon3d
And some other minor changes.
This commit is contained in:
dln
2014-03-05 18:22:43 +04:00
committed by abv
parent 84c71f29e4
commit f62de37212
37 changed files with 3482 additions and 4806 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/IntCurveSurface/FILES
View File

@@ -1,2 +0,0 @@
IntCurveSurface_SurfaceTool.gxx

2
src/IntCurveSurface/IntCurveSurface.cdl
View File

@@ -80,8 +80,6 @@ is
--------------------------------------------------
generic class HCurveTool;
--------------------------------------------------
generic class SurfaceTool;
--------------------------------------------------
generic class Polygon;
--------------------------------------------------
generic class Polyhedron;

240
src/IntCurveSurface/IntCurveSurface_SurfaceTool.cdl
View File

@@ -1,240 +0,0 @@
-- Created on: 1993-07-02
-- Created by: Laurent BUCHARD
-- 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.
generic class SurfaceTool from IntCurveSurface
( TheSurface as any)
uses
Shape from GeomAbs,
SurfaceType from GeomAbs,
Pln from gp,
Cone from gp,
Cylinder from gp,
Sphere from gp,
Torus from gp,
Pnt from gp,
Vec from gp,
Array1OfReal from TColStd,
BezierSurface from Geom,
BSplineSurface from Geom,
HSurface from Adaptor3d,
HCurve from Adaptor3d,
Ax1 from gp,
Dir from gp
raises
NoSuchObject from Standard,
OutOfRange from Standard
is
FirstUParameter(myclass; S: TheSurface)
---C++: inline
returns Real from Standard;
FirstVParameter(myclass; S: TheSurface)
---C++: inline
returns Real from Standard;
LastUParameter(myclass; S: TheSurface)
---C++: inline
returns Real from Standard;
LastVParameter(myclass; S: TheSurface)
---C++: inline
returns Real from Standard;
NbUIntervals(myclass; S: TheSurface;
Sh : Shape from GeomAbs)
---C++: inline
returns Integer from Standard;
NbVIntervals(myclass; S: TheSurface;
Sh : Shape from GeomAbs)
---C++: inline
returns Integer from Standard;
UIntervals(myclass; S : TheSurface;
T : in out Array1OfReal from TColStd;
Sh : Shape from GeomAbs);
---C++: inline
VIntervals(myclass; S : TheSurface;
T : in out Array1OfReal from TColStd;
Sh : Shape from GeomAbs) ;
---C++: inline
UTrim(myclass; S : TheSurface;
First, Last, Tol : Real)
---C++: inline
returns HSurface from Adaptor3d
raises
OutOfRange from Standard;
---Purpose: If <First> >= <Last>
VTrim(myclass; S : TheSurface;
First, Last, Tol : Real)
---C++: inline
returns HSurface from Adaptor3d
raises
OutOfRange from Standard;
---Purpose: If <First> >= <Last>
IsUClosed(myclass; S: TheSurface)
---C++: inline
returns Boolean from Standard;
IsVClosed(myclass; S: TheSurface)
---C++: inline
returns Boolean from Standard;
IsUPeriodic(myclass; S: TheSurface)
---C++: inline
returns Boolean from Standard;
UPeriod(myclass; S: TheSurface)
---C++: inline
returns Real from Standard;
IsVPeriodic(myclass; S: TheSurface)
---C++: inline
returns Boolean from Standard;
VPeriod(myclass; S: TheSurface)
---C++: inline
returns Real from Standard;
Value(myclass; S : TheSurface;
u,v : Real from Standard)
---C++: inline
returns Pnt from gp;
D0(myclass; S : TheSurface;
u,v : Real from Standard;
P : out Pnt from gp);
---C++: inline
D1(myclass; S : TheSurface;
u,v : Real from Standard;
P : out Pnt from gp;
D1u,D1v: out Vec from gp);
---C++: inline
D2(myclass; S : TheSurface;
u,v : Real from Standard;
P : out Pnt from gp;
D1U,D1V,D2U,D2V,D2UV: out Vec from gp);
---C++: inline
D3(myclass; S : TheSurface;
u,v : Real from Standard;
P : out Pnt from gp;
D1U, D1V, D2U, D2V, D2UV, D3U, D3V, D3UUV, D3UVV: out Vec from gp);
---C++: inline
DN(myclass; S : TheSurface;
u,v : Real from Standard;
Nu,Nv : Integer from Standard)
---C++: inline
returns Vec from gp;
UResolution(myclass; S:TheSurface; R3d: Real from Standard)
---C++: inline
returns Real from Standard;
VResolution(myclass; S:TheSurface; R3d: Real from Standard)
---C++: inline
returns Real from Standard;
GetType(myclass; S: TheSurface)
---C++: inline
returns SurfaceType from GeomAbs;
Plane(myclass; S: TheSurface)
---C++: inline
returns Pln from gp;
Cylinder(myclass; S : TheSurface) returns Cylinder from gp
raises NoSuchObject from Standard;
---C++: inline
Cone(myclass; S : TheSurface) returns Cone from gp
raises NoSuchObject from Standard;
---C++: inline
Torus(myclass; S : TheSurface) returns Torus from gp
raises NoSuchObject from Standard;
---C++: inline
Sphere(myclass; S : TheSurface) returns Sphere from gp
raises NoSuchObject from Standard;
---C++: inline
Bezier(myclass; S : TheSurface) returns BezierSurface from Geom
raises NoSuchObject from Standard;
---C++: inline
BSpline(myclass; S : TheSurface) returns BSplineSurface from Geom
raises NoSuchObject from Standard;
---C++: inline
AxeOfRevolution(myclass; S: TheSurface) returns Ax1 from gp
raises NoSuchObject from Standard;
---C++: inline
Direction(myclass; S: TheSurface) returns Dir from gp
raises NoSuchObject from Standard;
---C++: inline
BasisCurve(myclass; S:TheSurface) returns HCurve from Adaptor3d
raises NoSuchObject from Standard;
---C++: inline
--------------------------------------------------------------------------------
NbSamplesU(myclass; S : TheSurface) returns Integer from Standard;
NbSamplesV(myclass; S : TheSurface) returns Integer from Standard;
NbSamplesU(myclass; S : TheSurface; u1,u2: Real from Standard) returns Integer from Standard;
NbSamplesV(myclass; S : TheSurface; v1,v2: Real from Standard) returns Integer from Standard;
end SurfaceTool;

139
src/IntCurveSurface/IntCurveSurface_SurfaceTool.gxx
View File

@@ -1,139 +0,0 @@
// Created by: Laurent BUCHARD
// 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.
//-- <lbr@nonox>
#include TheSurface_hxx
Standard_Integer IntCurveSurface_SurfaceTool::NbSamplesU(const TheSurface& S) {
Standard_Integer nbs;
GeomAbs_SurfaceType typS = S.GetType();
switch(typS) {
case GeomAbs_Plane:
{
nbs = 2;
}
break;
case GeomAbs_BezierSurface:
{
nbs = 3 + S.NbUPoles();
}
break;
case GeomAbs_BSplineSurface:
{
nbs = S.NbUKnots();
nbs*= S.UDegree();
if(nbs < 2) nbs=2;
}
break;
case GeomAbs_Torus:
{
nbs = 20;
}
break;
case GeomAbs_Cylinder:
case GeomAbs_Cone:
case GeomAbs_Sphere:
case GeomAbs_SurfaceOfRevolution:
case GeomAbs_SurfaceOfExtrusion:
{
nbs = 10;
}
break;
default:
{
nbs = 10;
}
break;
}
return(nbs);
}
Standard_Integer IntCurveSurface_SurfaceTool::NbSamplesV(const TheSurface& S) {
Standard_Integer nbs;
GeomAbs_SurfaceType typS = S.GetType();
switch(typS) {
case GeomAbs_Plane:
{
nbs = 2;
}
break;
case GeomAbs_BezierSurface:
{
nbs = 3 + S.NbVPoles();
}
break;
case GeomAbs_BSplineSurface:
{
nbs = S.NbVKnots();
nbs*= S.VDegree();
if(nbs < 2) nbs=2;
}
break;
case GeomAbs_Cylinder:
case GeomAbs_Cone:
case GeomAbs_Sphere:
case GeomAbs_Torus:
case GeomAbs_SurfaceOfRevolution:
case GeomAbs_SurfaceOfExtrusion:
{
nbs = 15;
}
break;
default:
{
nbs = 10;
}
break;
}
return(nbs);
}
Standard_Integer IntCurveSurface_SurfaceTool::NbSamplesU(const TheSurface& S,
const Standard_Real u1,
const Standard_Real u2) {
Standard_Integer nbs = NbSamplesU(S);
Standard_Integer n = nbs;
if(nbs>10) {
Standard_Real uf = FirstUParameter(S);
Standard_Real ul = LastUParameter(S);
n*= (Standard_Integer)((u2-u1)/(uf-ul));
if(n>nbs) n = nbs;
if(n<5) n = 5;
}
return(n);
}
Standard_Integer IntCurveSurface_SurfaceTool::NbSamplesV(const TheSurface& S,
const Standard_Real v1,
const Standard_Real v2) {
Standard_Integer nbs = NbSamplesV(S);
Standard_Integer n = nbs;
if(nbs>10) {
Standard_Real vf = FirstVParameter(S);
Standard_Real vl = LastVParameter(S);
n*= (Standard_Integer)((v2-v1)/(vf-vl));
if(n>nbs) n = nbs;
if(n<5) n = 5;
}
return(n);
}

239
src/IntCurveSurface/IntCurveSurface_SurfaceTool.lxx
View File

@@ -1,239 +0,0 @@
// Created by: Laurent BUCHARD
// 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.
//-- <lbr@nonox>
#include TheSurface_hxx
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
#include <gp_Pln.hxx>
#include <gp_Cylinder.hxx>
#include <gp_Cone.hxx>
#include <gp_Torus.hxx>
#include <gp_Sphere.hxx>
#include <gp_Ax1.hxx>
#include <gp_Dir.hxx>
#include <Geom_BezierSurface.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_HCurve.hxx>
inline Standard_Real IntCurveSurface_SurfaceTool::FirstUParameter(const TheSurface& Surf){ return Surf.FirstUParameter(); }
inline Standard_Real IntCurveSurface_SurfaceTool::FirstVParameter(const TheSurface& Surf){ return Surf.FirstVParameter();}
inline Standard_Real IntCurveSurface_SurfaceTool::LastUParameter(const TheSurface& Surf){ return Surf.LastUParameter();}
inline Standard_Real IntCurveSurface_SurfaceTool::LastVParameter(const TheSurface& Surf){ return Surf.LastVParameter();}
inline Standard_Integer IntCurveSurface_SurfaceTool::NbUIntervals(const TheSurface& Surf,
const GeomAbs_Shape S){
return Surf.NbUIntervals(S);
}
inline Standard_Integer IntCurveSurface_SurfaceTool::NbVIntervals(const TheSurface& Surf,
const GeomAbs_Shape S){
return Surf.NbVIntervals(S);
}
inline void IntCurveSurface_SurfaceTool::UIntervals(const TheSurface& Surf,
TColStd_Array1OfReal& Tab,
const GeomAbs_Shape S){
Surf.UIntervals(Tab,S);
}
inline void IntCurveSurface_SurfaceTool::VIntervals(const TheSurface& Surf,
TColStd_Array1OfReal& Tab,
const GeomAbs_Shape S){
Surf.VIntervals(Tab,S);
}
inline Handle_Adaptor3d_HSurface IntCurveSurface_SurfaceTool::UTrim(const TheSurface& Surf,
const Standard_Real F,
const Standard_Real L,
const Standard_Real Tol) {
return Surf.UTrim(F,L,Tol);
}
inline Handle_Adaptor3d_HSurface IntCurveSurface_SurfaceTool::VTrim(const TheSurface& Surf,
const Standard_Real F,
const Standard_Real L,
const Standard_Real Tol) {
return Surf.VTrim(F,L,Tol);
}
inline Standard_Boolean IntCurveSurface_SurfaceTool::IsUClosed(const TheSurface& S)
{
return S.IsUClosed();
}
inline Standard_Boolean IntCurveSurface_SurfaceTool::IsVClosed(const TheSurface& S)
{
return S.IsVClosed();
}
inline Standard_Boolean IntCurveSurface_SurfaceTool::IsUPeriodic(const TheSurface& S)
{
return S.IsUPeriodic();
}
inline Standard_Real IntCurveSurface_SurfaceTool::UPeriod(const TheSurface& S)
{
return S.UPeriod();
}
inline Standard_Boolean IntCurveSurface_SurfaceTool::IsVPeriodic(const TheSurface& S)
{
return S.IsVPeriodic();
}
inline Standard_Real IntCurveSurface_SurfaceTool::VPeriod(const TheSurface& S)
{
return S.VPeriod();
}
inline gp_Pnt IntCurveSurface_SurfaceTool::Value(const TheSurface& S,
const Standard_Real U,
const Standard_Real V )
{
return S.Value(U,V);
}
inline void IntCurveSurface_SurfaceTool::D0(const TheSurface& S,
const Standard_Real U,
const Standard_Real V,
gp_Pnt& P)
{
S.D0(U,V,P);
}
inline void IntCurveSurface_SurfaceTool::D1(const TheSurface& S,
const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D1U,
gp_Vec& D1V)
{
S.D1(U,V,P,D1U,D1V);
}
inline void IntCurveSurface_SurfaceTool::D2(const TheSurface& S,
const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D1U,
gp_Vec& D1V,
gp_Vec& D2U,
gp_Vec& D2V,
gp_Vec& D2UV)
{
S.D2(U,V,P,D1U,D1V,D2U,D2V,D2UV);
}
inline void IntCurveSurface_SurfaceTool::D3(const TheSurface& S,
const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D1U,
gp_Vec& D1V,
gp_Vec& D2U,
gp_Vec& D2V,
gp_Vec& D2UV,
gp_Vec& D3U,
gp_Vec& D3V,
gp_Vec& D3UUV,
gp_Vec& D3UVV)
{
S.D3(U,V,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV);
}
inline gp_Vec IntCurveSurface_SurfaceTool::DN(const TheSurface& S,
const Standard_Real U,
const Standard_Real V,
const Standard_Integer Nu,
const Standard_Integer Nv)
{
return S.DN(U,V,Nu,Nv);
}
inline Standard_Real IntCurveSurface_SurfaceTool::UResolution(const TheSurface& S,
const Standard_Real R3d)
{
return S.UResolution(R3d);
}
inline Standard_Real IntCurveSurface_SurfaceTool::VResolution(const TheSurface& S,
const Standard_Real R3d)
{
return S.VResolution(R3d);
}
inline GeomAbs_SurfaceType IntCurveSurface_SurfaceTool::GetType(const TheSurface& S )
{
return S.GetType();
}
inline gp_Pln IntCurveSurface_SurfaceTool::Plane(const TheSurface& S)
{
return S.Plane();
}
inline gp_Cylinder IntCurveSurface_SurfaceTool::Cylinder(const TheSurface& S)
{
return S.Cylinder();
}
inline gp_Cone IntCurveSurface_SurfaceTool::Cone(const TheSurface& S)
{
return S.Cone();
}
inline gp_Sphere IntCurveSurface_SurfaceTool::Sphere(const TheSurface& S)
{
return S.Sphere();
}
inline gp_Torus IntCurveSurface_SurfaceTool::Torus(const TheSurface& S)
{
return S.Torus();
}
inline Handle(Geom_BezierSurface) IntCurveSurface_SurfaceTool::Bezier(const TheSurface& S) {
return(S.Bezier());
}
inline Handle(Geom_BSplineSurface) IntCurveSurface_SurfaceTool::BSpline(const TheSurface& S) {
return(S.BSpline());
}
inline gp_Ax1 IntCurveSurface_SurfaceTool::AxeOfRevolution(const TheSurface& S) {
return(S.AxeOfRevolution());
}
inline gp_Dir IntCurveSurface_SurfaceTool::Direction(const TheSurface& S) {
return(S.Direction());
}
inline Handle(Adaptor3d_HCurve) IntCurveSurface_SurfaceTool::BasisCurve(const TheSurface& S) {
return(S.BasisCurve());
}