2010-05-14 21:15:28 +06:00
|
|
|
// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
|
2005-12-05 21:23:52 +05:00
|
|
|
//
|
2009-02-13 17:16:39 +05:00
|
|
|
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
|
|
|
|
|
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
|
2005-12-05 21:23:52 +05:00
|
|
|
//
|
2009-02-13 17:16:39 +05:00
|
|
|
// This library 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 2.1 of the License.
|
|
|
|
|
//
|
|
|
|
|
// This library 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 this library; if not, write to the Free Software
|
|
|
|
|
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
|
//
|
|
|
|
|
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
|
2005-12-05 21:23:52 +05:00
|
|
|
//
|
2003-07-09 21:01:54 +06:00
|
|
|
// File : GEOM_Gen.idl
|
2004-12-01 15:39:14 +05:00
|
|
|
// Author : Sergey RUIN
|
2010-11-25 17:31:41 +05:00
|
|
|
|
2003-05-12 20:51:31 +06:00
|
|
|
#ifndef __GEOM_GEN__
|
|
|
|
|
#define __GEOM_GEN__
|
|
|
|
|
|
|
|
|
|
#include "SALOME_Exception.idl"
|
|
|
|
|
#include "SALOME_Component.idl"
|
|
|
|
|
#include "SALOMEDS.idl"
|
2008-03-07 12:45:34 +05:00
|
|
|
#include "SALOMEDS_Attributes.idl"
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
#include "SALOME_GenericObj.idl"
|
2003-05-12 20:51:31 +06:00
|
|
|
|
|
|
|
|
module GEOM
|
|
|
|
|
{
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Topological types of shapes (like Open Cascade types)
|
|
|
|
|
*/
|
|
|
|
|
enum shape_type { COMPOUND, COMPSOLID, SOLID, SHELL,
|
2009-02-13 17:16:39 +05:00
|
|
|
FACE, WIRE, EDGE, VERTEX, SHAPE };
|
2004-12-01 15:39:14 +05:00
|
|
|
|
2009-12-08 17:05:55 +05:00
|
|
|
/*!
|
|
|
|
|
* Marker type
|
|
|
|
|
*/
|
|
|
|
|
enum marker_type { MT_NONE, MT_POINT, MT_PLUS, MT_STAR, MT_O, MT_X, MT_O_POINT, MT_O_PLUS,
|
2010-11-25 17:31:41 +05:00
|
|
|
MT_O_STAR, MT_O_X, MT_BALL, MT_RING1, MT_RING2, MT_RING3, MT_USER };
|
2009-12-08 17:05:55 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Marker size
|
|
|
|
|
*/
|
|
|
|
|
enum marker_size { MS_NONE, MS_10, MS_15, MS_20, MS_25, MS_30, MS_35,
|
2010-11-25 17:31:41 +05:00
|
|
|
MS_40, MS_45, MS_50, MS_55, MS_60, MS_65, MS_70 };
|
2005-01-21 14:16:41 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* State of shape relatively geometrical surface like plane, sphere or cylinder.
|
|
|
|
|
* Is used in functions GEOM_IShapesOperations.GetShapesOn<xxx>()
|
|
|
|
|
*/
|
|
|
|
|
enum shape_state
|
|
|
|
|
{
|
|
|
|
|
/*! Shape is on surface */
|
|
|
|
|
ST_ON,
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Shape is in the direction defined by the normal and not on surface.
|
|
|
|
|
* For plane it means above the plane,
|
|
|
|
|
* For sphere and cylinder it means outside of volume, bounded by the surface.
|
|
|
|
|
*/
|
|
|
|
|
ST_OUT,
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Shape is in the direction defined by the normal and on surface.
|
|
|
|
|
* ONOUT = ON || OUT
|
|
|
|
|
*/
|
|
|
|
|
ST_ONOUT,
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Complementary to ONOUT.
|
|
|
|
|
* For plane it means below the plane,
|
|
|
|
|
* For sphere and cylinder it means inside the volume, bounded by the surface
|
|
|
|
|
* (beyond axis and surface for cylinder and beyond cented and surface for sphere).
|
|
|
|
|
*/
|
|
|
|
|
ST_IN,
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Complementary to OUT.
|
|
|
|
|
* ONIN = ON || IN
|
|
|
|
|
*/
|
|
|
|
|
ST_ONIN
|
|
|
|
|
};
|
|
|
|
|
|
2009-02-13 17:16:39 +05:00
|
|
|
/*!
|
|
|
|
|
* Kind of method to find inside one main shape some subshapes,
|
|
|
|
|
* corresponding to other given shape (its argument)
|
|
|
|
|
* Is used in functions GEOM_Gen.RestoreSubShapes<xxx>()
|
|
|
|
|
*/
|
|
|
|
|
enum find_shape_method
|
|
|
|
|
{
|
|
|
|
|
/*! Use GetInPlace functionality. Suits all cases, except transformations */
|
|
|
|
|
FSM_GetInPlace,
|
|
|
|
|
|
|
|
|
|
/*! To be used only for transformation result, to find subshapes of argument.
|
|
|
|
|
* Only this method can be used after transformation.
|
|
|
|
|
*/
|
|
|
|
|
FSM_Transformed,
|
|
|
|
|
|
|
|
|
|
/*! To find only shared subshapes, not modified by the operation */
|
|
|
|
|
FSM_GetSame,
|
|
|
|
|
|
|
|
|
|
/*! Use GetShapesOnShape method (can work only on solids) */
|
|
|
|
|
FSM_GetShapesOnShape,
|
|
|
|
|
|
|
|
|
|
/*! Use GetInPlaceByHistory method (can work only after Partition) */
|
2010-12-24 13:16:18 +05:00
|
|
|
FSM_GetInPlaceByHistory,
|
|
|
|
|
|
|
|
|
|
/*! To be used only for multi-transformation result.
|
|
|
|
|
* Only this method can be used after multi-transformation.
|
|
|
|
|
*/
|
|
|
|
|
FSM_MultiTransformed
|
2009-02-13 17:16:39 +05:00
|
|
|
};
|
|
|
|
|
|
2010-05-14 21:15:28 +06:00
|
|
|
/*!
|
|
|
|
|
* Kind of method to perform filling operation
|
|
|
|
|
* Is used in functions GEOM_Gen.MakeFilling<xxx>()
|
|
|
|
|
*/
|
|
|
|
|
enum filling_oper_method
|
|
|
|
|
{
|
|
|
|
|
/*! Default (standard behaviour) */
|
|
|
|
|
FOM_Default,
|
|
|
|
|
|
|
|
|
|
/*! Use edges orientation */
|
|
|
|
|
FOM_UseOri,
|
|
|
|
|
|
|
|
|
|
/*! Auto-correct edges orientation */
|
|
|
|
|
FOM_AutoCorrect
|
|
|
|
|
};
|
|
|
|
|
|
2009-02-13 17:16:39 +05:00
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
typedef sequence<string> string_array;
|
|
|
|
|
typedef sequence<short> short_array;
|
2011-02-18 12:55:09 +05:00
|
|
|
typedef sequence<boolean> ListOfBool;
|
2004-12-01 15:39:14 +05:00
|
|
|
typedef sequence<long> ListOfLong;
|
|
|
|
|
typedef sequence<double> ListOfDouble;
|
|
|
|
|
|
|
|
|
|
interface GEOM_Object;
|
|
|
|
|
|
|
|
|
|
typedef sequence<GEOM_Object> ListOfGO;
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* GEOM_Object: interface of geometric object
|
|
|
|
|
*/
|
|
|
|
|
interface GEOM_Object : SALOME::GenericObj
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get an entry of the object in GEOM component.
|
|
|
|
|
*/
|
|
|
|
|
string GetEntry();
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get ID of study, where the object is created.
|
|
|
|
|
*/
|
|
|
|
|
long GetStudyID();
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get internal type of the object (POINT, BOX, CYLINDER, EXTRUSION...).
|
|
|
|
|
*/
|
|
|
|
|
long GetType();
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get a <VAR>shape_type</VAR> of the object value.
|
|
|
|
|
*/
|
|
|
|
|
shape_type GetShapeType();
|
|
|
|
|
|
2010-11-25 17:31:41 +05:00
|
|
|
/*!
|
|
|
|
|
* Get the topology type of the object value.
|
|
|
|
|
* In contrast to the shape type, this function returns type of the most
|
|
|
|
|
* top-level sub-shape of the COMPOUND or COMPSOLID, if there is only one
|
|
|
|
|
* sub-shape there.
|
|
|
|
|
* \sa GetShapeType()
|
|
|
|
|
*/
|
|
|
|
|
shape_type GetTopologyType();
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get a minimal type of the top-level shapes contained in the object.
|
|
|
|
|
* This function is useful for the compounds only; for simple shapes it
|
|
|
|
|
* exactly the same value as GetShapeType().
|
|
|
|
|
* Note, that compounds are procesed recursively.
|
2010-12-24 13:16:18 +05:00
|
|
|
* \sa GetShapeType(), GetTopologyType(), GetMaxShapeType()
|
2010-11-25 17:31:41 +05:00
|
|
|
*/
|
|
|
|
|
shape_type GetMinShapeType();
|
|
|
|
|
|
2010-12-24 13:16:18 +05:00
|
|
|
/*!
|
|
|
|
|
* Get a maximal type of the top-level shapes contained in the object.
|
|
|
|
|
* This function is useful for the compounds only; for simple shapes it
|
|
|
|
|
* exactly the same value as GetShapeType().
|
|
|
|
|
* Note, that compounds are procesed recursively.
|
|
|
|
|
* \sa GetShapeType(), GetTopologyType(), GetMinShapeType()
|
|
|
|
|
*/
|
|
|
|
|
shape_type GetMaxShapeType();
|
2011-02-28 19:44:44 +05:00
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Set name of the object.
|
|
|
|
|
* \param theName is a name which will be associated with this object.
|
|
|
|
|
*/
|
|
|
|
|
void SetName (in string theName);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get name of the object associated with this object.
|
|
|
|
|
*/
|
|
|
|
|
string GetName();
|
|
|
|
|
|
2008-03-07 12:45:34 +05:00
|
|
|
/*!
|
|
|
|
|
* Set color of the object.
|
|
|
|
|
* \param theColor is a color of the object.
|
|
|
|
|
*/
|
|
|
|
|
void SetColor(in SALOMEDS::Color theColor);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get color of the object.
|
|
|
|
|
*/
|
|
|
|
|
SALOMEDS::Color GetColor();
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Toggle auto color mode on the object.
|
|
|
|
|
* \param theAtoColor is a flag which toggles auto color mode.
|
|
|
|
|
*/
|
|
|
|
|
void SetAutoColor(in boolean theAutoColor);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get flag of object's auto color mode.
|
|
|
|
|
*/
|
|
|
|
|
boolean GetAutoColor();
|
|
|
|
|
|
2009-12-08 17:05:55 +05:00
|
|
|
/*!
|
|
|
|
|
* Set standard point marker for the object
|
|
|
|
|
* \param theType standard marker type
|
|
|
|
|
* \param theSize marker relative size
|
|
|
|
|
*/
|
|
|
|
|
void SetMarkerStd(in marker_type theType, in marker_size theSize );
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Set custom point marker for the object. The texture can be added
|
|
|
|
|
* by LoadTexture() or AddTexture() functions.
|
|
|
|
|
* \param theTextureId texture ID
|
|
|
|
|
*/
|
|
|
|
|
void SetMarkerTexture(in long theTextureId);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get type of the point marker assigned to the object
|
|
|
|
|
* \return current marker type (MT_NONE if no marker is set)
|
|
|
|
|
*/
|
|
|
|
|
marker_type GetMarkerType();
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get size of the point marker assigned to the object
|
|
|
|
|
* \return current marker relative size (MS_NONE if no marker is set)
|
|
|
|
|
*/
|
|
|
|
|
marker_size GetMarkerSize();
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get texture idenifier of the point marker assigned to the object
|
|
|
|
|
* \return marker texture ID (0 if no marker set)
|
|
|
|
|
*/
|
|
|
|
|
long GetMarkerTexture();
|
|
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Set a Study entry where this object was published.
|
|
|
|
|
*/
|
|
|
|
|
void SetStudyEntry (in string theEntry);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get a Study entry where this object was published.
|
|
|
|
|
*/
|
|
|
|
|
string GetStudyEntry();
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get a list of all GEOM objects on which were the arguments
|
|
|
|
|
* when this object was constructed and modified.
|
|
|
|
|
* \note This method is supposed to be used by GUI only.
|
|
|
|
|
*/
|
|
|
|
|
ListOfGO GetDependency();
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get a list of GEOM objects on which the last function that created or modified the object depends.
|
|
|
|
|
* \note This method is supposed to be used by GUI only.
|
|
|
|
|
*/
|
|
|
|
|
ListOfGO GetLastDependency();
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get the TopoDS_Shape, for colocated case only.
|
|
|
|
|
*/
|
2008-03-07 12:45:34 +05:00
|
|
|
long long getShape();
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
######################################################################
|
|
|
|
|
* Internal methods (For sub shape identification)
|
|
|
|
|
######################################################################
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get geometric shape of the object as a byte stream
|
|
|
|
|
*/
|
|
|
|
|
SALOMEDS::TMPFile GetShapeStream();
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Returns True if this object is not a sub shape of another object.
|
|
|
|
|
*/
|
|
|
|
|
boolean IsMainShape();
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Get a list of ID's of sub shapes in the main shape.
|
|
|
|
|
* \note Internal method, suppopsed to be used only by GEOM_Client
|
|
|
|
|
*/
|
|
|
|
|
ListOfLong GetSubShapeIndices();
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Get a main shape object to which this object is a sub shape
|
|
|
|
|
* \note Internal method, suppopsed to be used only by GEOM_Client
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetMainShape();
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Return true if geom object representes a shape.
|
|
|
|
|
* For example, method return false for GEOM_MARKER
|
|
|
|
|
*/
|
|
|
|
|
boolean IsShape();
|
2009-02-13 17:16:39 +05:00
|
|
|
|
2011-01-10 15:16:57 +05:00
|
|
|
/*
|
|
|
|
|
* Return true if passed object is identical to this object
|
|
|
|
|
* \param other object being compared with this one
|
|
|
|
|
*/
|
|
|
|
|
boolean IsSame(in GEOM_Object other);
|
2011-02-28 19:44:44 +05:00
|
|
|
|
2009-02-13 17:16:39 +05:00
|
|
|
/*!
|
|
|
|
|
* Set list of parameters
|
|
|
|
|
* \param theParameters is a string containing the notebook variables separated by ":" symbol,
|
|
|
|
|
* used for object creation
|
|
|
|
|
*/
|
|
|
|
|
void SetParameters (in string theParameters);
|
2009-12-08 17:05:55 +05:00
|
|
|
|
2009-02-13 17:16:39 +05:00
|
|
|
/*!
|
|
|
|
|
* Return list of notebook variables used for object creation separated by ":" symbol
|
|
|
|
|
*/
|
|
|
|
|
string GetParameters();
|
2004-12-01 15:39:14 +05:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* GEOM_IOperations: basic methods of all geometric operations
|
|
|
|
|
*/
|
|
|
|
|
interface GEOM_IOperations : SALOME::GenericObj
|
|
|
|
|
{
|
|
|
|
|
/*!
|
|
|
|
|
* To know, if the operation was successfully performed
|
|
|
|
|
*/
|
|
|
|
|
boolean IsDone();
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Set the operation error code
|
|
|
|
|
* \param theErrorID is a string describing the error occured
|
|
|
|
|
* \note This method is supposed to be used only by interfaces inheriting from IOperations.
|
|
|
|
|
*/
|
|
|
|
|
void SetErrorCode (in string theErrorID);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get the operation error code
|
|
|
|
|
*/
|
|
|
|
|
string GetErrorCode();
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get ID of study, where the operation is defined
|
|
|
|
|
*/
|
|
|
|
|
long GetStudyID();
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Opens a new transaction
|
|
|
|
|
*/
|
|
|
|
|
void StartOperation();
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Closes the previously opened trasaction
|
|
|
|
|
*/
|
|
|
|
|
void FinishOperation();
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Aborts the previously opened transaction
|
|
|
|
|
*/
|
|
|
|
|
void AbortOperation();
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* GEOM_IBasicOperations: interface for basic geometry creation
|
|
|
|
|
* (Point, Vector, Plane, Marker)
|
|
|
|
|
*/
|
|
|
|
|
interface GEOM_IBasicOperations : GEOM_IOperations
|
|
|
|
|
{
|
|
|
|
|
/*!
|
|
|
|
|
* Create point by three coordinates.
|
|
|
|
|
* \param theX The X coordinate of the point.
|
|
|
|
|
* \param theY The Y coordinate of the point.
|
|
|
|
|
* \param theZ The Z coordinate of the point.
|
|
|
|
|
* \return New GEOM_Object, containing the created point.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePointXYZ (in double theX, in double theY, in double theZ);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a point, distant from the referenced point
|
|
|
|
|
* on the given distances along the coordinate axes.
|
|
|
|
|
* \param theReference The referenced point.
|
|
|
|
|
* \param theX Displacement from the referenced point along OX axis.
|
|
|
|
|
* \param theY Displacement from the referenced point along OY axis.
|
|
|
|
|
* \param theZ Displacement from the referenced point along OZ axis.
|
|
|
|
|
* \return New GEOM_Object, containing the created point.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePointWithReference (in GEOM_Object theReference,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theX, in double theY, in double theZ);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a point, corresponding to the given parameter on the given curve.
|
|
|
|
|
* \param theRefCurve The referenced curve.
|
|
|
|
|
* \param theParameter Value of parameter on the referenced curve.
|
|
|
|
|
* \return New GEOM_Object, containing the created point.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePointOnCurve (in GEOM_Object theRefCurve,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theParameter);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
2010-12-17 15:15:39 +05:00
|
|
|
/*!
|
|
|
|
|
* Create a point, corresponding to the given length on the given curve.
|
|
|
|
|
* \param theRefCurve The referenced curve.
|
|
|
|
|
* \param theLength Length on the referenced curve.
|
2011-01-07 02:40:34 +05:00
|
|
|
* \param theReverse Direction for the calculation of the length (false = forward or true = reversed).
|
2010-12-17 15:15:39 +05:00
|
|
|
* \return New GEOM_Object, containing the created point.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePointOnCurveByLength (in GEOM_Object theRefCurve,
|
2011-01-05 22:33:52 +05:00
|
|
|
in double theLength,
|
2011-01-07 02:40:34 +05:00
|
|
|
in boolean theReverse);
|
2010-12-17 15:15:39 +05:00
|
|
|
|
2009-08-27 18:47:34 +06:00
|
|
|
/*!
|
|
|
|
|
* Create a point on the given curve, projecting given point
|
|
|
|
|
* \param theRefCurve The referenced curve.
|
|
|
|
|
* \param theXParameter X co-ordinate of point to project on curve
|
|
|
|
|
* \param theYParameter Y co-ordinate of point to project on curve
|
|
|
|
|
* \param theZParameter Z co-ordinate of point to project on curve
|
|
|
|
|
* \return New GEOM_Object, containing the created point.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePointOnCurveByCoord (in GEOM_Object theRefCurve,
|
|
|
|
|
in double theXParameter,
|
|
|
|
|
in double theYarameter,
|
|
|
|
|
in double theZPameter);
|
|
|
|
|
|
2009-02-13 17:16:39 +05:00
|
|
|
/*!
|
|
|
|
|
* Create a point, corresponding to the given parameters on the
|
|
|
|
|
* given surface.
|
|
|
|
|
* \param theRefSurf The referenced surface.
|
|
|
|
|
* \param theUParameter Value of U-parameter on the referenced surface.
|
|
|
|
|
* \param theVParameter Value of V-parameter on the referenced surface.
|
|
|
|
|
* \return New GEOM_Object, containing the created point.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePointOnSurface (in GEOM_Object theRefSurf,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theUParameter,
|
|
|
|
|
in double theVParameter);
|
2009-02-13 17:16:39 +05:00
|
|
|
|
2009-08-27 18:47:34 +06:00
|
|
|
/*!
|
|
|
|
|
* Create a point on the given surface, projecting given point
|
|
|
|
|
* \param theRefSurf The referenced surface.
|
|
|
|
|
* \param theXParameter X co-ordinate of point to project on curve
|
|
|
|
|
* \param theYParameter Y co-ordinate of point to project on curve
|
|
|
|
|
* \param theZParameter Z co-ordinate of point to project on curve
|
|
|
|
|
* \return New GEOM_Object, containing the created point.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePointOnSurfaceByCoord (in GEOM_Object theRefSurf,
|
|
|
|
|
in double theXParameter,
|
|
|
|
|
in double theYarameter,
|
|
|
|
|
in double theZPameter);
|
|
|
|
|
|
|
|
|
|
|
2008-03-07 12:45:34 +05:00
|
|
|
/*!
|
|
|
|
|
* Create a point, on two lines intersection.
|
|
|
|
|
* \param theRefLine1, theRefLine2 The referenced lines.
|
|
|
|
|
* \return New GEOM_Object, containing the created point.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePointOnLinesIntersection (in GEOM_Object theRefLine1,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theRefLine2);
|
2009-02-13 17:16:39 +05:00
|
|
|
|
2006-06-01 17:32:40 +06:00
|
|
|
/*!
|
|
|
|
|
* Create a vector, corresponding to tangent to the given parameter on the given curve.
|
|
|
|
|
* \param theRefCurve The referenced curve.
|
|
|
|
|
* \param theParameter Value of parameter on the referenced curve.This value should be have value
|
|
|
|
|
* \between 0. and 1.. Value of 0. corresponds first parameter of curve value 1. corresponds
|
2009-02-13 17:16:39 +05:00
|
|
|
* \last parameter of curve.
|
2006-06-01 17:32:40 +06:00
|
|
|
* \return New GEOM_Object, containing the created point.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeTangentOnCurve (in GEOM_Object theRefCurve,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theParameter);
|
2006-06-01 17:32:40 +06:00
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Create a vector with the given components.
|
|
|
|
|
* \param theDX X component of the vector.
|
|
|
|
|
* \param theDY Y component of the vector.
|
|
|
|
|
* \param theDZ Z component of the vector.
|
|
|
|
|
* \return New GEOM_Object, containing the created vector.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeVectorDXDYDZ (in double theDX,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theDY,
|
|
|
|
|
in double theDZ);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a vector between two points.
|
|
|
|
|
* \param thePnt1 Start point for the vector.
|
|
|
|
|
* \param thePnt2 End point for the vector.
|
|
|
|
|
* \return New GEOM_Object, containing the created vector.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeVectorTwoPnt (in GEOM_Object thePnt1, in GEOM_Object thePnt2);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a line, passing through the given point
|
|
|
|
|
* and parrallel to the given direction
|
|
|
|
|
* \param thePnt Point. The resulting line will pass through it.
|
|
|
|
|
* \param theDir Direction. The resulting line will be parallel to it.
|
|
|
|
|
* \return New GEOM_Object, containing the created line.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeLine (in GEOM_Object thePnt, in GEOM_Object theDir);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a line, passing through the given points
|
|
|
|
|
* \param thePnt1 First of two points, defining the line.
|
|
|
|
|
* \param thePnt2 Second of two points, defining the line.
|
|
|
|
|
* \return New GEOM_Object, containing the created line.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeLineTwoPnt (in GEOM_Object thePnt1, in GEOM_Object thePnt2);
|
|
|
|
|
|
2008-03-07 12:45:34 +05:00
|
|
|
/*!
|
|
|
|
|
* Create a line, given by two faces intersection.
|
|
|
|
|
* \param theFace1 First of two faces, defining the line.
|
|
|
|
|
* \param theFace2 Second of two faces, defining the line.
|
|
|
|
|
* \return New GEOM_Object, containing the created line.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeLineTwoFaces (in GEOM_Object theFace1, in GEOM_Object theFace2);
|
|
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Create a plane, passing through the three given points
|
|
|
|
|
* \param thePnt1 First of three points, defining the plane.
|
|
|
|
|
* \param thePnt2 Second of three points, defining the plane.
|
|
|
|
|
* \param thePnt3 Fird of three points, defining the plane.
|
|
|
|
|
* \param theTrimSize Half size of a side of quadrangle face, representing the plane.
|
|
|
|
|
* \return New GEOM_Object, containing the created plane.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePlaneThreePnt (in GEOM_Object thePnt1,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object thePnt2,
|
|
|
|
|
in GEOM_Object thePnt3,
|
|
|
|
|
in double theTrimSize);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a plane, passing through the given point
|
|
|
|
|
* and normal to the given vector.
|
|
|
|
|
* \param thePnt Point, the plane has to pass through.
|
|
|
|
|
* \param theVec Vector, defining the plane normal direction.
|
|
|
|
|
* \param theTrimSize Half size of a side of quadrangle face, representing the plane.
|
|
|
|
|
* \return New GEOM_Object, containing the created plane.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePlanePntVec (in GEOM_Object thePnt,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theVec,
|
|
|
|
|
in double theTrimSize);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a plane, similar to the existing one, but with another size of representing face.
|
2008-03-07 12:45:34 +05:00
|
|
|
* \param theFace Referenced plane or LCS(Marker).
|
2004-12-01 15:39:14 +05:00
|
|
|
* \param theTrimSize New half size of a side of quadrangle face, representing the plane.
|
|
|
|
|
* \return New GEOM_Object, containing the created plane.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePlaneFace (in GEOM_Object theFace,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theTrimSize);
|
2009-12-08 17:05:55 +05:00
|
|
|
|
2009-05-22 14:17:16 +06:00
|
|
|
/*!
|
|
|
|
|
* Create a plane, by two vectors.
|
|
|
|
|
* \param theVec1 Vector1, the plane has to pass through first point of this vector.
|
|
|
|
|
* \param theVec Vector2, defining the plane normal direction.
|
|
|
|
|
* \param theTrimSize Half size of a side of quadrangle face, representing the plane.
|
|
|
|
|
* \return New GEOM_Object, containing the created plane.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePlane2Vec (in GEOM_Object theVec1,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theVec2,
|
|
|
|
|
in double theTrimSize);
|
2009-12-08 17:05:55 +05:00
|
|
|
|
2009-05-22 14:17:16 +06:00
|
|
|
/*!
|
|
|
|
|
* Create a plane, defined by local coordinate system.
|
|
|
|
|
* \param theLCS Referenced LCS(Marker).
|
|
|
|
|
* \param theTrimSize Half size of a side of quadrangle face, representing the plane.
|
|
|
|
|
* \param theOrientation OXY, OYZ or OZX orientation = (1, 2 or 3).
|
|
|
|
|
* \return New GEOM_Object, containing the created plane.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePlaneLCS (in GEOM_Object theLCS,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theTrimSize,
|
|
|
|
|
in double theOrientation);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a local coordinate system.
|
|
|
|
|
* \param theOX,theOY,theOZ Three coordinates of coordinate system origin.
|
|
|
|
|
* \param theXDX,theXDY,theXDZ Three components of OX direction
|
|
|
|
|
* \param theYDX,theYDY,theYDZ Three components of OY direction
|
|
|
|
|
* \return New GEOM_Object, containing the created coordinate system.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeMarker (in double theOX , in double theOY , in double theOZ,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theXDX, in double theXDY, in double theXDZ,
|
|
|
|
|
in double theYDX, in double theYDY, in double theYDZ);
|
2009-02-13 17:16:39 +05:00
|
|
|
|
2010-01-19 13:21:42 +05:00
|
|
|
/*!
|
|
|
|
|
* Create a local coordinate system from shape.
|
|
|
|
|
* \param theShape The initial shape to detect the coordinate system.
|
|
|
|
|
* \return New GEOM_Object, containing the created coordinate system.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeMarkerFromShape (in GEOM_Object theShape);
|
2010-11-25 17:31:41 +05:00
|
|
|
|
2010-01-19 13:21:42 +05:00
|
|
|
/*!
|
|
|
|
|
* Create a local coordinate system from point and two vectors (DX, DY).
|
|
|
|
|
* \param theOrigin Point of coordinate system origin.
|
|
|
|
|
* \param theXVec Vector of X direction.
|
|
|
|
|
* \param theYVec Vector of Y direction.
|
|
|
|
|
* \return New GEOM_Object, containing the created coordinate system.
|
|
|
|
|
*/
|
2011-02-28 19:44:44 +05:00
|
|
|
GEOM_Object MakeMarkerPntTwoVec (in GEOM_Object theOrigin,
|
|
|
|
|
in GEOM_Object theXVec, in GEOM_Object theYVec);
|
2010-11-25 17:31:41 +05:00
|
|
|
|
2006-06-01 17:32:40 +06:00
|
|
|
/*!
|
|
|
|
|
* Create a tangent plane to specified face in the point with specified parameters.
|
|
|
|
|
* Values of parameters should be between 0. and 1.0
|
2009-02-13 17:16:39 +05:00
|
|
|
* \param theFace - face for which tangent plane shuold be built.
|
2006-06-01 17:32:40 +06:00
|
|
|
* \param theParameterU - value of parameter by U
|
|
|
|
|
* \param theParameterV - value of parameter Vthe
|
|
|
|
|
* \param theTrimSize - defines sizes of created face
|
|
|
|
|
* \return New GEOM_Object, containing the face built on tangent plane.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeTangentPlaneOnFace(in GEOM_Object theFace,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theParameterU,
|
|
|
|
|
in double theParameterV,
|
|
|
|
|
in double theTrimSize);
|
2004-12-01 15:39:14 +05:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
interface GEOM_ITransformOperations : GEOM_IOperations
|
|
|
|
|
{
|
|
|
|
|
/*!
|
|
|
|
|
* Translate the given object along the vector, specified by its end points.
|
|
|
|
|
* \param theObject The object to be translated.
|
|
|
|
|
* \param thePoint1 Start point of translation vector.
|
|
|
|
|
* \param thePoint2 End point of translation vector.
|
|
|
|
|
* \return theObject.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object TranslateTwoPoints (in GEOM_Object theObject,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object thePoint1,
|
|
|
|
|
in GEOM_Object thePoint2);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Translate the given object along the vector, specified
|
|
|
|
|
* by its end points, creating its copy before the translation.
|
|
|
|
|
* \param theObject The object to be translated.
|
|
|
|
|
* \param thePoint1 Start point of translation vector.
|
|
|
|
|
* \param thePoint2 End point of translation vector.
|
|
|
|
|
* \return New GEOM_Object, containing the translated object.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object TranslateTwoPointsCopy (in GEOM_Object theObject,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object thePoint1,
|
2004-12-01 15:39:14 +05:00
|
|
|
in GEOM_Object thePoint2);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Translate the given object along the vector, specified by its components.
|
|
|
|
|
* \param theObject The object to be translated.
|
|
|
|
|
* \param theDX,theDY,theDZ Components of translation vector.
|
|
|
|
|
* \return theObject.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object TranslateDXDYDZ (in GEOM_Object theObject,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theDX, in double theDY, in double theDZ);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Translate the given object along the vector, specified
|
|
|
|
|
* by its components, creating its copy before the translation.
|
|
|
|
|
* \param theObject The object to be translated.
|
|
|
|
|
* \param theDX,theDY,theDZ Components of translation vector.
|
|
|
|
|
* \return New GEOM_Object, containing the translated object.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object TranslateDXDYDZCopy (in GEOM_Object theObject,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theDX, in double theDY, in double theDZ);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Translate the given object along the given vector.
|
|
|
|
|
* \param theObject The object to be translated.
|
|
|
|
|
* \param theVector Translation vector, giving both direction and distance.
|
|
|
|
|
* \return theObject.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object TranslateVector (in GEOM_Object theObject,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theVector);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Translate the given object along the given vector,
|
|
|
|
|
* creating its copy before the translation.
|
|
|
|
|
* \param theObject The object to be translated.
|
|
|
|
|
* \param theVector Translation vector, giving both direction and distance.
|
|
|
|
|
* \return New GEOM_Object, containing the translated object.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object TranslateVectorCopy (in GEOM_Object theObject,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theVector);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
2009-02-13 17:16:39 +05:00
|
|
|
/*!
|
|
|
|
|
* Translate the given object along the given vector on given distance,
|
|
|
|
|
* creating its copy before the translation.
|
|
|
|
|
* \param theObject The object to be translated.
|
|
|
|
|
* \param theVector Translation vector, giving a direction.
|
|
|
|
|
* \param theDistance Translation distance, giving a distance.
|
|
|
|
|
* \param theCope Translation copy, creating its copy if true.
|
|
|
|
|
* \return New GEOM_Object, containing the translated object.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object TranslateVectorDistance (in GEOM_Object theObject,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theVector,
|
|
|
|
|
in double theDistance,
|
|
|
|
|
in boolean theCopy);
|
2009-02-13 17:16:39 +05:00
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Translate the given object along the given vector a given number times
|
|
|
|
|
* \param theObject The object to be translated.
|
|
|
|
|
* \param theVector Direction of the translation.
|
|
|
|
|
* \param theStep Distance to translate on.
|
|
|
|
|
* \param theNbTimes Quantity of translations to be done.
|
|
|
|
|
* \return New GEOM_Object, containing compound of all
|
|
|
|
|
* the shapes, obtained after each translation.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MultiTranslate1D (in GEOM_Object theObject,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theVector,
|
|
|
|
|
in double theStep,
|
|
|
|
|
in long theNbTimes);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Conseqently apply two specified translations to theObject specified number of times.
|
|
|
|
|
* \param theObject The object to be translated.
|
|
|
|
|
* \param theVector1 Direction of the first translation.
|
|
|
|
|
* \param theStep1 Step of the first translation.
|
|
|
|
|
* \param theNbTimes1 Quantity of translations to be done along theVector1.
|
|
|
|
|
* \param theVector2 Direction of the second translation.
|
|
|
|
|
* \param theStep2 Step of the second translation.
|
|
|
|
|
* \param theNbTimes2 Quantity of translations to be done along theVector2.
|
|
|
|
|
* \return New GEOM_Object, containing compound of all
|
|
|
|
|
* the shapes, obtained after each translation.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MultiTranslate2D (in GEOM_Object theObject,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theVector1,
|
|
|
|
|
in double theStep1,
|
|
|
|
|
in long theNbTimes1,
|
|
|
|
|
in GEOM_Object theVector2,
|
|
|
|
|
in double theStep2,
|
|
|
|
|
in long theNbTimes2);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
2008-03-07 12:45:34 +05:00
|
|
|
/*!
|
|
|
|
|
* Rotate given object around vector perpendicular to plane containing three points.
|
|
|
|
|
* \param theObject The object to be rotated.
|
|
|
|
|
* \param theCentPoint central point - the axis is the vector perpendicular to the plane
|
|
|
|
|
* containing the three points.
|
|
|
|
|
* \param thePoint1 and thePoint2 - in a perpendicular plan of the axis.
|
|
|
|
|
* \return theObject.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object RotateThreePoints (in GEOM_Object theObject,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theCentPoint,
|
|
|
|
|
in GEOM_Object thePoint1,
|
|
|
|
|
in GEOM_Object thePoint2);
|
2008-03-07 12:45:34 +05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Rotate given object around vector perpendicular to plane containing three points.
|
|
|
|
|
* Creating its copy before the rotatation.
|
|
|
|
|
* \param theObject The object to be rotated.
|
|
|
|
|
* \param theCentPoint central point - the axis is the vector perpendicular to the plane
|
|
|
|
|
* containing the three points.
|
|
|
|
|
* \param thePoint1 and thePoint2 - in a perpendicular plan of the axis.
|
|
|
|
|
* \return New GEOM_Object, containing the rotated object.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object RotateThreePointsCopy (in GEOM_Object theObject,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theCentPoint,
|
|
|
|
|
in GEOM_Object thePoint1,
|
|
|
|
|
in GEOM_Object thePoint2);
|
2008-03-07 12:45:34 +05:00
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Rotate the given object around the given axis on the given angle.
|
|
|
|
|
* \param theObject The object to be rotated.
|
|
|
|
|
* \param theAxis Rotation axis.
|
|
|
|
|
* \param theAngle Rotation angle in radians.
|
|
|
|
|
* \return theObject.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object Rotate (in GEOM_Object theObject,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theAxis,
|
|
|
|
|
in double theAngle);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
2008-03-07 12:45:34 +05:00
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Rotate the given object around the given axis
|
|
|
|
|
* on the given angle, creating its copy before the rotatation.
|
|
|
|
|
* \param theObject The object to be rotated.
|
|
|
|
|
* \param theAxis Rotation axis.
|
|
|
|
|
* \param theAngle Rotation angle in radians.
|
|
|
|
|
* \return New GEOM_Object, containing the rotated object.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object RotateCopy (in GEOM_Object theObject,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theAxis,
|
|
|
|
|
in double theAngle);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
2008-03-07 12:45:34 +05:00
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Rotate the given object around the given axis a given number times.
|
|
|
|
|
* Rotation angle will be 2*PI/theNbTimes.
|
|
|
|
|
* \param theObject The object to be rotated.
|
|
|
|
|
* \param theAxis The rotation axis.
|
|
|
|
|
* \param theNbTimes Quantity of rotations to be done.
|
|
|
|
|
* \return New GEOM_Object, containing compound of all the
|
|
|
|
|
* shapes, obtained after each rotation.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MultiRotate1D (in GEOM_Object theObject,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theAxis,
|
|
|
|
|
in long theNbTimes);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Rotate the given object around the
|
|
|
|
|
* given axis on the given angle a given number
|
|
|
|
|
* times and multi-translate each rotation result.
|
|
|
|
|
* Translation direction passes through center of gravity
|
|
|
|
|
* of rotated shape and its projection on the rotation axis.
|
|
|
|
|
* \param theObject The object to be rotated.
|
|
|
|
|
* \param theAxis Rotation axis.
|
|
|
|
|
* \param theAngle Rotation angle in graduces.
|
|
|
|
|
* \param theNbTimes1 Quantity of rotations to be done.
|
|
|
|
|
* \param theStep Translation distance.
|
|
|
|
|
* \param theNbTimes2 Quantity of translations to be done.
|
|
|
|
|
* \return New GEOM_Object, containing compound of all the
|
|
|
|
|
* shapes, obtained after each transformation.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MultiRotate2D (in GEOM_Object theObject,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theAxis,
|
|
|
|
|
in double theAngle,
|
|
|
|
|
in long theNbTimes1,
|
|
|
|
|
in double theStep,
|
|
|
|
|
in long theNbTimes2);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Replace the given object by an object,
|
|
|
|
|
* symmetrical to it relatively the given plane.
|
|
|
|
|
* \param theObject The object to be mirrored.
|
|
|
|
|
* \param thePlane Plane of symmetry.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MirrorPlane (in GEOM_Object theObject, in GEOM_Object thePlane);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create an object, symmetrical
|
|
|
|
|
* to the given one relatively the given plane.
|
|
|
|
|
* \param theObject The object to be mirrored.
|
|
|
|
|
* \param thePlane Plane of symmetry.
|
|
|
|
|
* \return New GEOM_Object, containing the mirrored shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MirrorPlaneCopy (in GEOM_Object theObject, in GEOM_Object thePlane);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Replace the given object by an object,
|
|
|
|
|
* symmetrical to it relatively the given axis.
|
|
|
|
|
* \param theObject The object to be mirrored.
|
|
|
|
|
* \param theAxis Axis of symmetry.
|
|
|
|
|
* \return theObject.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MirrorAxis (in GEOM_Object theObject, in GEOM_Object theAxis);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create an object, symmetrical
|
|
|
|
|
* to the given one relatively the given axis.
|
|
|
|
|
* \param theObject The object to be mirrored.
|
|
|
|
|
* \param theAxis Axis of symmetry.
|
|
|
|
|
* \return New GEOM_Object, containing the mirrored object.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MirrorAxisCopy (in GEOM_Object theObject, in GEOM_Object theAxis);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Replace the given object by an object, symmetrical to it relatively the given point.
|
|
|
|
|
* \param theObject The object to be mirrored.
|
|
|
|
|
* \param thePoint Point of symmetry.
|
|
|
|
|
* \return theObject.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MirrorPoint (in GEOM_Object theObject, in GEOM_Object thePoint);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create an object, symmetrical to the given one relatively the given point.
|
|
|
|
|
* \param theObject The object to be mirrored.
|
|
|
|
|
* \param thePoint Point of symmetry.
|
|
|
|
|
* \return New GEOM_Object, containing the mirrored object.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MirrorPointCopy (in GEOM_Object theObject, in GEOM_Object thePoint);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Replace the given object by its offset.
|
|
|
|
|
* \param theObject The base object for the offset.
|
|
|
|
|
* \param theOffset Offset value.
|
|
|
|
|
* \return theObject.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object OffsetShape (in GEOM_Object theObject, in double theOffset);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create new object as offset of the given one.
|
|
|
|
|
* \param theObject The base object for the offset.
|
|
|
|
|
* \param theOffset Offset value.
|
|
|
|
|
* \return New GEOM_Object, containing the offset object.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object OffsetShapeCopy (in GEOM_Object theObject, in double theOffset);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Scale the given object by the factor.
|
|
|
|
|
* \param theObject The object to be scaled.
|
|
|
|
|
* \param thePoint Center point for scaling.
|
|
|
|
|
* \param theFactor Scaling factor value.
|
|
|
|
|
* \return theObject.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object ScaleShape (in GEOM_Object theObject, in GEOM_Object thePoint,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theFactor);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Scale the given object by the factor, creating its copy before the scaling.
|
|
|
|
|
* \param theObject The object to be scaled.
|
|
|
|
|
* \param thePoint Center point for scaling.
|
|
|
|
|
* \param theFactor Scaling factor value.
|
|
|
|
|
* \return New GEOM_Object, containing the scaled shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object ScaleShapeCopy (in GEOM_Object theObject, in GEOM_Object thePoint,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theFactor);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
2009-02-13 17:16:39 +05:00
|
|
|
/*!
|
|
|
|
|
* Scale the given object by different factors along coordinate axes.
|
|
|
|
|
* \param theObject The object to be scaled.
|
|
|
|
|
* \param thePoint Center point for scaling.
|
|
|
|
|
* \param theFactorX,theFactorY,theFactorZ Scaling factors along each axis.
|
|
|
|
|
* \return theObject.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object ScaleShapeAlongAxes (in GEOM_Object theObject,
|
|
|
|
|
in GEOM_Object thePoint,
|
|
|
|
|
in double theFactorX,
|
|
|
|
|
in double theFactorY,
|
|
|
|
|
in double theFactorZ);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Scale the given object by different factors along coordinate axes,
|
|
|
|
|
* creating its copy before the scaling.
|
|
|
|
|
* \param theObject The object to be scaled.
|
|
|
|
|
* \param thePoint Center point for scaling.
|
|
|
|
|
* \param theFactorX,theFactorY,theFactorZ Scaling factors along each axis.
|
|
|
|
|
* \return New GEOM_Object, containing the scaled shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object ScaleShapeAlongAxesCopy (in GEOM_Object theObject,
|
|
|
|
|
in GEOM_Object thePoint,
|
|
|
|
|
in double theFactorX,
|
|
|
|
|
in double theFactorY,
|
|
|
|
|
in double theFactorZ);
|
|
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
2008-03-07 12:45:34 +05:00
|
|
|
* Modify the Location of the given object by LCS.
|
|
|
|
|
* \param theObject The object to be displaced.
|
|
|
|
|
* \param theStartLCS Coordinate system to perform displacement from it.
|
|
|
|
|
* If \a theStartLCS is NULL, displacement
|
|
|
|
|
* will be performed from global CS.
|
|
|
|
|
* If \a theObject itself is used as \a theStartLCS,
|
|
|
|
|
* its location will be changed to \a theEndLCS.
|
|
|
|
|
* \param theEndLCS Coordinate system to perform displacement to it.
|
|
|
|
|
* \return theObject.
|
2004-12-01 15:39:14 +05:00
|
|
|
*/
|
|
|
|
|
GEOM_Object PositionShape (in GEOM_Object theObject,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theStartLCS,
|
|
|
|
|
in GEOM_Object theEndLCS);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
2008-03-07 12:45:34 +05:00
|
|
|
* Modify the Location of the given object by LCS,
|
|
|
|
|
* creating its copy before the setting.
|
|
|
|
|
* \param theObject The object to be displaced.
|
|
|
|
|
* \param theStartLCS Coordinate system to perform displacement from it.
|
|
|
|
|
* If \a theStartLCS is NULL, displacement
|
|
|
|
|
* will be performed from global CS.
|
|
|
|
|
* If \a theObject itself is used as \a theStartLCS,
|
|
|
|
|
* its location will be changed to \a theEndLCS.
|
|
|
|
|
* \param theEndLCS Coordinate system to perform displacement to it.
|
|
|
|
|
* \return New GEOM_Object, containing the displaced shape.
|
2004-12-01 15:39:14 +05:00
|
|
|
*/
|
|
|
|
|
GEOM_Object PositionShapeCopy (in GEOM_Object theObject,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theStartLCS,
|
|
|
|
|
in GEOM_Object theEndLCS);
|
2009-02-13 17:16:39 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Modify the Location of the given object by Path,
|
|
|
|
|
* \param theObject The object to be displaced.
|
|
|
|
|
* \param thePath Wire or Edge along that the object will be translated.
|
2011-02-28 19:44:44 +05:00
|
|
|
* \param theDistance progress of Path (0 = actual location, 1 = end of path location).
|
|
|
|
|
* \param theCopy is a true or false parameter. true is to create a copy, false to move the object.
|
|
|
|
|
* \param theCopy is a true or false parameter. true is to reverse direction, false is to move normal direction.
|
2009-02-13 17:16:39 +05:00
|
|
|
* \return New GEOM_Object, containing the displaced shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object PositionAlongPath (in GEOM_Object theObject,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object thePath,
|
|
|
|
|
in double theDistance,
|
|
|
|
|
in boolean theCopy,
|
|
|
|
|
in boolean theReverse);
|
2009-02-13 17:16:39 +05:00
|
|
|
|
2010-12-24 13:16:18 +05:00
|
|
|
/*!
|
|
|
|
|
* Transform the shape in the same way what was used for the sample shape creation.
|
|
|
|
|
* \param theObject The object to be transformed.
|
|
|
|
|
* \param theSample The object containing information about required transformation.
|
|
|
|
|
* \note Implementation of this method is limited by multi-transformations now.
|
|
|
|
|
* \note Internal method.
|
|
|
|
|
* \return New GEOM_Object, containing the transformed shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object TransformLikeOtherCopy (in GEOM_Object theObject,
|
|
|
|
|
in GEOM_Object theSample);
|
|
|
|
|
|
2009-02-13 17:16:39 +05:00
|
|
|
/*!
|
|
|
|
|
* Recompute the shape from its arguments.
|
|
|
|
|
* \param theObject The object to be recomputed.
|
|
|
|
|
* \return theObject.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object RecomputeObject (in GEOM_Object theObject);
|
2004-12-01 15:39:14 +05:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* GEOM_I3DPrimOperations: Interface for 3D primitives creation
|
|
|
|
|
* Box, Cylinder, Cone, Sphere, Prism (extrusion),
|
|
|
|
|
* Pipe (extrusion along contour), Revolution, Solid (from shell).
|
|
|
|
|
*/
|
|
|
|
|
interface GEOM_I3DPrimOperations : GEOM_IOperations
|
|
|
|
|
{
|
|
|
|
|
/*!
|
|
|
|
|
* Create a box with specified dimensions along the coordinate axes
|
|
|
|
|
* and with edges, parallel to the coordinate axes.
|
|
|
|
|
* Center of the box will be at point (DX/2, DY/2, DZ/2).
|
|
|
|
|
* \param theDX Length of Box edges, parallel to OX axis.
|
|
|
|
|
* \param theDY Length of Box edges, parallel to OY axis.
|
|
|
|
|
* \param theDZ Length of Box edges, parallel to OZ axis.
|
|
|
|
|
* \return New GEOM_Object, containing the created box.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeBoxDXDYDZ (in double theDX, in double theDY, in double theDZ);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a box with two specified opposite vertices,
|
|
|
|
|
* and with edges, parallel to the coordinate axes
|
|
|
|
|
* \param thePnt1 First of two opposite vertices.
|
|
|
|
|
* \param thePnt2 Second of two opposite vertices.
|
|
|
|
|
* \return New GEOM_Object, containing the created box.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeBoxTwoPnt (in GEOM_Object thePnt1, in GEOM_Object thePnt2);
|
|
|
|
|
|
2009-02-13 17:16:39 +05:00
|
|
|
/*!
|
|
|
|
|
* Create a face specified dimensions along OX-OY coordinate axes,
|
|
|
|
|
* with edges parallel to the coordinate axes.
|
|
|
|
|
* Center of the face will be at point (0, 0, 0).
|
|
|
|
|
* \param theH Height of the Face.
|
|
|
|
|
* \param theW Width of the Face.
|
|
|
|
|
* \param theOrientation Orientation belong axis OXY OYZ OZX
|
|
|
|
|
* \return New GEOM_Object, containing the created face.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeFaceHW (in double theH, in double theW, in short theOrientation);
|
|
|
|
|
/*!
|
|
|
|
|
* Create a face by normale vector or edge and two specified sizes,
|
|
|
|
|
* vertical (H) and horisontal (W).
|
|
|
|
|
* \param theVec defines plane.
|
|
|
|
|
* \param theH vertical size (height).
|
2009-12-08 17:05:55 +05:00
|
|
|
* \param theW horisontal size (width).
|
2009-02-13 17:16:39 +05:00
|
|
|
* \return New GEOM_Object, containing the created face.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeFaceObjHW (in GEOM_Object theObj, in double theH, in double theW);
|
|
|
|
|
/*!
|
|
|
|
|
* Create a Disk (circular face) with given center, normal vector and radius.
|
|
|
|
|
* \param thePnt disk center.
|
|
|
|
|
* \param theVec Vector, normal to the plane of the disk.
|
|
|
|
|
* \param theR Disk radius.
|
|
|
|
|
* \return New GEOM_Object, containing the created disk.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeDiskPntVecR (in GEOM_Object thePnt,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theVec,
|
|
|
|
|
in double theR);
|
2009-02-13 17:16:39 +05:00
|
|
|
/*!
|
|
|
|
|
* Create a disk (circular face), passing through three given points
|
|
|
|
|
* \param thePnt1, thePnt2, thePnt3 Points, defining the disk.
|
|
|
|
|
* \return New GEOM_Object, containing the created disk.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeDiskThreePnt (in GEOM_Object thePnt1,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object thePnt2,
|
|
|
|
|
in GEOM_Object thePnt3);
|
2009-12-08 17:05:55 +05:00
|
|
|
|
2009-02-13 17:16:39 +05:00
|
|
|
/*!
|
|
|
|
|
* Create a disk specified dimensions along OX-OY coordinate axes,
|
|
|
|
|
* Center of the disk at point (0, 0, 0).
|
|
|
|
|
* \param theR of the Disk.
|
|
|
|
|
* \param theOrientation Orientation belong axis OXY OYZ OZX
|
|
|
|
|
* \return New GEOM_Object, containing the created disk.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeDiskR (in double theR, in short theOrientation);
|
2009-12-08 17:05:55 +05:00
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Create a cylinder with given radius and height at
|
|
|
|
|
* the origin of coordinate system. Axis of the cylinder
|
|
|
|
|
* will be collinear to the OZ axis of the coordinate system.
|
|
|
|
|
* \param theR Cylinder radius.
|
|
|
|
|
* \param theH Cylinder height.
|
|
|
|
|
* \return New GEOM_Object, containing the created cylinder.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeCylinderRH (in double theR, in double theH);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a cylinder with given base point, axis, radius and height.
|
|
|
|
|
* \param thePnt Central point of cylinder base.
|
|
|
|
|
* \param theAxis Cylinder axis.
|
|
|
|
|
* \param theR Cylinder radius.
|
|
|
|
|
* \param theH Cylinder height.
|
|
|
|
|
* \return New GEOM_Object, containing the created cylinder.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeCylinderPntVecRH (in GEOM_Object thePnt,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theAxis,
|
|
|
|
|
in double theR,
|
|
|
|
|
in double theH);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a cone with given height and radiuses at
|
|
|
|
|
* the origin of coordinate system. Axis of the cone will
|
|
|
|
|
* be collinear to the OZ axis of the coordinate system.
|
|
|
|
|
* \param theR1 Radius of the first cone base.
|
|
|
|
|
* \param theR2 Radius of the second cone base.
|
|
|
|
|
* \note If both radiuses are non-zero, the cone will be truncated.
|
|
|
|
|
* \note If the radiuses are equal, a cylinder will be created instead.
|
|
|
|
|
* \param theH Cone height.
|
|
|
|
|
* \return New GEOM_Object, containing the created cone.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeConeR1R2H (in double theR1, in double theR2, in double theH);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a cone with given base point, axis, height and radiuses.
|
|
|
|
|
* \param thePnt Central point of the first cone base.
|
|
|
|
|
* \param theAxis Cone axis.
|
|
|
|
|
* \param theR1 Radius of the first cone base.
|
|
|
|
|
* \param theR2 Radius of the second cone base.
|
|
|
|
|
* \note If both radiuses are non-zero, the cone will be truncated.
|
|
|
|
|
* \note If the radiuses are equal, a cylinder will be created instead.
|
|
|
|
|
* \param theH Cone height.
|
|
|
|
|
* \return New GEOM_Object, containing the created cone.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeConePntVecR1R2H (in GEOM_Object thePnt,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theAxis,
|
|
|
|
|
in double theR1,
|
|
|
|
|
in double theR2,
|
|
|
|
|
in double theH);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a torus with given radiuses at the origin of coordinate system.
|
|
|
|
|
* \param theRMajor Torus major radius.
|
|
|
|
|
* \param theRMinor Torus minor radius.
|
|
|
|
|
* \return New GEOM_Object, containing the created torus.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeTorusRR (in double theRMajor,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theRMinor);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a torus with given center, normal vector and radiuses.
|
|
|
|
|
* \param thePnt Torus central point.
|
|
|
|
|
* \param theVec Torus axis of symmetry.
|
|
|
|
|
* \param theRMajor Torus major radius.
|
|
|
|
|
* \param theRMinor Torus minor radius.
|
|
|
|
|
* \return New GEOM_Object, containing the created torus.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeTorusPntVecRR (in GEOM_Object thePnt,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theVec,
|
|
|
|
|
in double theRMajor,
|
|
|
|
|
in double theRMinor);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a sphere with given radius at the origin of coordinate system.
|
|
|
|
|
* \param theR Sphere radius.
|
|
|
|
|
* \return New GEOM_Object, containing the created sphere.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeSphereR (in double theR);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a sphere with given center and radius.
|
|
|
|
|
* \param thePnt Sphere center.
|
|
|
|
|
* \param theR Sphere radius.
|
|
|
|
|
* \return New GEOM_Object, containing the created .
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeSpherePntR (in GEOM_Object thePnt, in double theR);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a shape by extrusion of the base shape along the vector,
|
|
|
|
|
* i.e. all the space, transfixed by the base shape during its translation
|
|
|
|
|
* along the vector on the given distance.
|
|
|
|
|
* \param theBase Base shape to be extruded.
|
|
|
|
|
* \param theVec Direction of extrusion.
|
|
|
|
|
* \param theH Prism dimension along theVec.
|
|
|
|
|
* \return New GEOM_Object, containing the created prism.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePrismVecH (in GEOM_Object theBase,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theVec,
|
|
|
|
|
in double theH);
|
2008-03-07 12:45:34 +05:00
|
|
|
/* The Same Prism but in 2 directions (forward&backward) */
|
|
|
|
|
GEOM_Object MakePrismVecH2Ways (in GEOM_Object theBase,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theVec,
|
|
|
|
|
in double theH);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a shape by extrusion of the base shape along a vector, defined by two points.
|
|
|
|
|
* \param theBase Base shape to be extruded.
|
|
|
|
|
* \param thePoint1 First end of extrusion vector.
|
|
|
|
|
* \param thePoint2 Second end of extrusion vector.
|
|
|
|
|
* \return New GEOM_Object, containing the created prism.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePrismTwoPnt (in GEOM_Object theBase,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object thePoint1,
|
|
|
|
|
in GEOM_Object thePoint2);
|
2008-03-07 12:45:34 +05:00
|
|
|
/* The same prism but in two directions forward&backward */
|
|
|
|
|
GEOM_Object MakePrismTwoPnt2Ways (in GEOM_Object theBase,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object thePoint1,
|
|
|
|
|
in GEOM_Object thePoint2);
|
2009-12-08 17:05:55 +05:00
|
|
|
|
2009-02-13 17:16:39 +05:00
|
|
|
/*!
|
|
|
|
|
* Create a shape by extrusion of the base shape along a vector, defined by DX DY DZ.
|
|
|
|
|
* \param theBase Base shape to be extruded.
|
|
|
|
|
* \param DX, DY, DZ end of extrusion vector.
|
|
|
|
|
* \return New GEOM_Object, containing the created prism.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePrismDXDYDZ (in GEOM_Object theBase,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theDX, in double theDY, in double theDZ);
|
2009-02-13 17:16:39 +05:00
|
|
|
/* The same prism but in two directions forward&backward */
|
|
|
|
|
GEOM_Object MakePrismDXDYDZ2Ways (in GEOM_Object theBase,
|
|
|
|
|
in double theDX, in double theDY, in double theDZ);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a shape by extrusion of the base shape along
|
|
|
|
|
* the path shape. The path shape can be a wire or an edge.
|
|
|
|
|
* \param theBase Base shape to be extruded.
|
|
|
|
|
* \param thePath Path shape to extrude the base shape along it.
|
|
|
|
|
* \return New GEOM_Object, containing the created pipe.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePipe (in GEOM_Object theBase, in GEOM_Object thePath);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a shape by revolution of the base shape around the axis
|
|
|
|
|
* on the given angle, i.e. all the space, transfixed by the base
|
|
|
|
|
* shape during its rotation around the axis on the given angle.
|
|
|
|
|
* \param theBase Base shape to be rotated.
|
|
|
|
|
* \param theAxis Rotation axis.
|
|
|
|
|
* \param theAngle Rotation angle in radians.
|
|
|
|
|
* \return New GEOM_Object, containing the created revolution.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeRevolutionAxisAngle (in GEOM_Object theBase,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theAxis,
|
|
|
|
|
in double theAngle);
|
2008-03-07 12:45:34 +05:00
|
|
|
/* The Same Revolution but in both ways forward&backward */
|
|
|
|
|
GEOM_Object MakeRevolutionAxisAngle2Ways (in GEOM_Object theBase,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theAxis,
|
|
|
|
|
in double theAngle);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a filling from the given compound of contours.
|
2008-03-07 12:45:34 +05:00
|
|
|
* \param theMinDeg a minimal degree of BSpline surface to create
|
|
|
|
|
* \param theMaxDeg a maximal degree of BSpline surface to create
|
|
|
|
|
* \param theTol2D a 2d tolerance to be reached
|
|
|
|
|
* \param theTol3D a 3d tolerance to be reached
|
|
|
|
|
* \param theNbIter a number of iteration of approximation algorithm
|
2010-05-14 21:15:28 +06:00
|
|
|
* \param theMethod Kind of method to perform filling operation.
|
2004-12-01 15:39:14 +05:00
|
|
|
* \return New GEOM_Object, containing the created filling surface.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeFilling (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in long theMinDeg, in long theMaxDeg,
|
|
|
|
|
in double theTol2D, in double theTol3D,
|
|
|
|
|
in long theNbIter,
|
2010-05-14 21:15:28 +06:00
|
|
|
in filling_oper_method theMethod,
|
|
|
|
|
in boolean theApprox);
|
2006-06-01 17:32:40 +06:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a shell or solid passing through set of sections.Sections should be wires,edges or vertices.
|
|
|
|
|
* \param theSeqSections - set of specified sections.
|
|
|
|
|
* \param theModeSolid - mode defining building solid or shell
|
|
|
|
|
* \param thePreci - precision 3D used for smoothing by default 1.e-6
|
|
|
|
|
* \param theRuled - mode defining type of the result surfaces (ruled or smoothed).
|
|
|
|
|
* \return New GEOM_Object, containing the created shell or solid.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeThruSections(in ListOfGO theSeqSections,
|
2010-11-25 17:31:41 +05:00
|
|
|
in boolean theModeSolid,
|
|
|
|
|
in double thePreci,
|
2006-06-01 17:32:40 +06:00
|
|
|
in boolean theRuled);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a shape by extrusion of the profile shape along
|
|
|
|
|
* the path shape. The path shape can be a wire or an edge.
|
2009-12-08 17:05:55 +05:00
|
|
|
* the several profiles can be specified in the several locations of path.
|
2006-06-01 17:32:40 +06:00
|
|
|
* \param theSeqBases - list of Bases shape to be extruded.
|
|
|
|
|
* \param theLocations - list of locations on the path corresponding
|
|
|
|
|
* specified list of the Bases shapes. Number of locations
|
|
|
|
|
* should be equal to number of bases or list of locations can be empty.
|
|
|
|
|
* \param thePath - Path shape to extrude the base shape along it.
|
|
|
|
|
* \param theWithContact - the mode defining that the section is translated to be in
|
|
|
|
|
* contact with the spine.
|
|
|
|
|
* \param - WithCorrection - defining that the section is rotated to be
|
2010-11-25 17:31:41 +05:00
|
|
|
* orthogonal to the spine tangent in the correspondent point
|
2006-06-01 17:32:40 +06:00
|
|
|
* \return New GEOM_Object, containing the created pipe.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePipeWithDifferentSections (in ListOfGO theSeqBases,
|
2010-11-25 17:31:41 +05:00
|
|
|
in ListOfGO theLocations,
|
|
|
|
|
in GEOM_Object thePath,
|
|
|
|
|
in boolean theWithContact ,
|
|
|
|
|
in boolean theWithCorrection );
|
2009-02-13 17:16:39 +05:00
|
|
|
|
2008-03-07 12:45:34 +05:00
|
|
|
/*!
|
|
|
|
|
* Create a shape by extrusion of the profile shape along
|
|
|
|
|
* the path shape. The path shape can be a shell or a face.
|
2009-12-08 17:05:55 +05:00
|
|
|
* the several profiles can be specified in the several locations of path.
|
2008-03-07 12:45:34 +05:00
|
|
|
* \param theSeqBases - list of Bases shape to be extruded.
|
|
|
|
|
* \param theSeqSubBases - list of corresponding subshapes of section shapes.
|
|
|
|
|
* \param theLocations - list of locations on the path corresponding
|
|
|
|
|
* specified list of the Bases shapes. Number of locations
|
|
|
|
|
* should be equal to number of bases.
|
|
|
|
|
* \param thePath - Path shape to extrude the base shape along it.
|
|
|
|
|
* \param theWithContact - the mode defining that the section is translated to be in
|
|
|
|
|
* contact with the spine.
|
|
|
|
|
* \param - WithCorrection - defining that the section is rotated to be
|
2010-11-25 17:31:41 +05:00
|
|
|
* orthogonal to the spine tangent in the correspondent point
|
2008-03-07 12:45:34 +05:00
|
|
|
* \return New GEOM_Object, containing the created pipe.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePipeWithShellSections (in ListOfGO theSeqBases,
|
2010-11-25 17:31:41 +05:00
|
|
|
in ListOfGO theSeqSubBases,
|
|
|
|
|
in ListOfGO theLocations,
|
|
|
|
|
in GEOM_Object thePath,
|
|
|
|
|
in boolean theWithContact ,
|
|
|
|
|
in boolean theWithCorrection );
|
2008-03-07 12:45:34 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create solids between given sections
|
|
|
|
|
* \param theSeqBases - list of sections (shell or face).
|
|
|
|
|
* \param theLocations - list of corresponding vertexes
|
|
|
|
|
* \return New GEOM_Object, containing the created solids.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePipeShellsWithoutPath (in ListOfGO theSeqBases,
|
2010-11-25 17:31:41 +05:00
|
|
|
in ListOfGO theLocations);
|
2009-02-13 17:16:39 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a shape by extrusion of the base shape along
|
2009-12-08 17:05:55 +05:00
|
|
|
* the path shape with constant bi-normal direction along the given vector.
|
2009-02-13 17:16:39 +05:00
|
|
|
* The path shape can be a wire or an edge.
|
|
|
|
|
* \param theBase Base shape to be extruded.
|
|
|
|
|
* \param thePath Path shape to extrude the base shape along it.
|
|
|
|
|
* \param theVec Vector defines a constant binormal direction to keep the
|
|
|
|
|
* same angle beetween the Direction and the sections
|
|
|
|
|
* along the sweep surface.
|
|
|
|
|
* \return New GEOM_Object, containing the created pipe.
|
|
|
|
|
*/
|
2009-12-08 17:05:55 +05:00
|
|
|
GEOM_Object MakePipeBiNormalAlongVector (in GEOM_Object theBase,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object thePath,
|
|
|
|
|
in GEOM_Object theVec);
|
2009-02-13 17:16:39 +05:00
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* GEOM_IShapesOperations: Interface for Shapes creation:
|
|
|
|
|
* Edge from two points, Wire from edges, Face from wire,
|
|
|
|
|
* Shell from faces, Solid from shells, Compound from shapes
|
|
|
|
|
*/
|
|
|
|
|
interface GEOM_IShapesOperations : GEOM_IOperations
|
|
|
|
|
{
|
|
|
|
|
/*!
|
|
|
|
|
* Create a linear edge with specified ends.
|
|
|
|
|
* \param thePnt1 Point for the first end of edge.
|
|
|
|
|
* \param thePnt2 Point for the second end of edge.
|
|
|
|
|
* \return New GEOM_Object, containing the created edge.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeEdge (in GEOM_Object thePnt1, in GEOM_Object thePnt2);
|
|
|
|
|
|
2010-11-25 17:31:41 +05:00
|
|
|
/*!
|
|
|
|
|
* Create an edge from specified wire.
|
|
|
|
|
* \param theWire source Wire.
|
|
|
|
|
* \param theLinearTolerance linear tolerance value
|
|
|
|
|
* \param theAngularTolerance angular tolerance value
|
|
|
|
|
* \return New GEOM_Object, containing the created edge.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeEdgeWire (in GEOM_Object theWire,
|
2011-02-28 19:44:44 +05:00
|
|
|
in double theLinearTolerance,
|
|
|
|
|
in double theAngularTolerance);
|
2010-11-25 17:31:41 +05:00
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Create a wire from the set of edges and wires.
|
|
|
|
|
* \param theEdgesAndWires List of edge and/or wires.
|
2009-05-27 17:46:05 +06:00
|
|
|
* \param theTolerance Maximum distance between vertices, that will be merged.
|
|
|
|
|
* Values less than 1e-07 are equivalent to 1e-07 (Precision::Confusion()).
|
2004-12-01 15:39:14 +05:00
|
|
|
* \return New GEOM_Object, containing the created wire.
|
|
|
|
|
*/
|
2009-05-27 17:46:05 +06:00
|
|
|
GEOM_Object MakeWire (in ListOfGO theEdgesAndWires,
|
|
|
|
|
in double theTolerance);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a face on the given wire.
|
2008-03-07 12:45:34 +05:00
|
|
|
* \param theWire closed Wire or Edge to build the face on.
|
2004-12-01 15:39:14 +05:00
|
|
|
* \param isPlanarWanted If TRUE, only planar face will be built.
|
|
|
|
|
* If impossible, NULL object will be returned.
|
|
|
|
|
* \return New GEOM_Object, containing the created face.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeFace (in GEOM_Object theWire, in boolean isPlanarWanted);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a face on the given wires set.
|
2008-03-07 12:45:34 +05:00
|
|
|
* \param theWires List of closed wires or edges to build the face on.
|
2004-12-01 15:39:14 +05:00
|
|
|
* \param isPlanarWanted If TRUE, only planar face will be built.
|
|
|
|
|
* If impossible, NULL object will be returned.
|
|
|
|
|
* \return New GEOM_Object, containing the created face.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeFaceWires (in ListOfGO theWires, in boolean isPlanarWanted);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a shell from the set of faces and shells.
|
|
|
|
|
* \param theFacesAndShells List of faces and/or shells.
|
|
|
|
|
* \return New GEOM_Object, containing the created shell.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeShell (in ListOfGO theFacesAndShells);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a solid, bounded by the given shell.
|
|
|
|
|
* \param theShell Bounding shell.
|
|
|
|
|
* \return New GEOM_Object, containing the created solid.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeSolidShell (in GEOM_Object theShell);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a solid, bounded by the given shells.
|
|
|
|
|
* \param theShells Bounding shells.
|
|
|
|
|
* \return New GEOM_Object, containing the created solid.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeSolidShells (in ListOfGO theShells);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a compound of the given shapes.
|
|
|
|
|
* \param theShapes List of shapes to put in compound.
|
|
|
|
|
* \return New GEOM_Object, containing the created compound.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeCompound (in ListOfGO theShapes);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Replace coincident faces in theShape by one face.
|
|
|
|
|
* \param theShape Initial shape.
|
|
|
|
|
* \param theTolerance Maximum distance between faces, which can be considered as coincident.
|
2008-03-07 12:45:34 +05:00
|
|
|
* \param doKeepNonSolids If FALSE, only solids will present in the result, otherwise all initial shapes.
|
2004-12-01 15:39:14 +05:00
|
|
|
* \return New GEOM_Object, containing a copy of theShape without coincident faces.
|
|
|
|
|
*/
|
2008-03-07 12:45:34 +05:00
|
|
|
GEOM_Object MakeGlueFaces (in GEOM_Object theShape, in double theTolerance, in boolean doKeepNonSolids);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Find coincident faces in theShape for possible gluing.
|
|
|
|
|
* \param theShape Initial shape.
|
|
|
|
|
* \param theTolerance Maximum distance between faces, which can be considered as coincident.
|
|
|
|
|
* \return ListOfGO
|
|
|
|
|
*/
|
|
|
|
|
ListOfGO GetGlueFaces (in GEOM_Object theShape, in double theTolerance);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Replace coincident faces in theShape by one face
|
|
|
|
|
* in compliance with given list of faces
|
|
|
|
|
* \param theShape Initial shape.
|
|
|
|
|
* \param theTolerance Maximum distance between faces, which can be considered as coincident.
|
|
|
|
|
* \param theFaces List of faces for gluing.
|
|
|
|
|
* \param doKeepNonSolids If FALSE, only solids will present in the result, otherwise all initial shapes.
|
|
|
|
|
* \return New GEOM_Object, containing a copy of theShape without some faces.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeGlueFacesByList (in GEOM_Object theShape, in double theTolerance,
|
2010-11-25 17:31:41 +05:00
|
|
|
in ListOfGO theFaces, in boolean doKeepNonSolids);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get all sub-shapes and groups of \a theShape,
|
|
|
|
|
* that were created already by any other methods.
|
|
|
|
|
* \param theShape Any shape.
|
|
|
|
|
* \param theGroupsOnly If this parameter is TRUE, only groups will be
|
|
|
|
|
* returned, else all found sub-shapes and groups.
|
|
|
|
|
* \return List of existing sub-objects of \a theShape.
|
|
|
|
|
*/
|
|
|
|
|
ListOfGO GetExistingSubObjects (in GEOM_Object theShape,
|
|
|
|
|
in boolean theGroupsOnly);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
2010-11-18 17:14:05 +05:00
|
|
|
/*!
|
|
|
|
|
* Deprecated method. Use MakeAllSubShapes() instead.
|
|
|
|
|
*/
|
|
|
|
|
ListOfGO MakeExplode (in GEOM_Object theShape,
|
2011-02-28 19:44:44 +05:00
|
|
|
in long theShapeType,
|
|
|
|
|
in boolean isSorted);
|
2010-11-18 17:14:05 +05:00
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
2011-02-04 19:50:33 +05:00
|
|
|
* Explode a shape on subshapes of a given type. If the
|
|
|
|
|
* shape itself has the given type, it is also returned.
|
2004-12-01 15:39:14 +05:00
|
|
|
* \param theShape Shape to be exploded.
|
|
|
|
|
* \param theShapeType Type of sub-shapes to be retrieved.
|
|
|
|
|
* \param isSorted If this parameter is TRUE, sub-shapes will be
|
|
|
|
|
* sorted by coordinates of their gravity centers.
|
|
|
|
|
* \return List of sub-shapes of type theShapeType, contained in theShape.
|
|
|
|
|
*/
|
2010-11-18 17:14:05 +05:00
|
|
|
ListOfGO MakeAllSubShapes (in GEOM_Object theShape,
|
|
|
|
|
in long theShapeType,
|
2011-02-04 19:50:33 +05:00
|
|
|
in boolean isSorted);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Extract all subshapes of the given type from
|
|
|
|
|
* the given shape, excluding the shape itself.
|
|
|
|
|
* \param theShape Shape to be exploded.
|
|
|
|
|
* \param theShapeType Type of sub-shapes to be retrieved.
|
|
|
|
|
* \param isSorted If this parameter is TRUE, sub-shapes will be
|
|
|
|
|
* sorted by coordinates of their gravity centers.
|
|
|
|
|
* \return List of sub-shapes of type theShapeType, contained in theShape.
|
|
|
|
|
*/
|
|
|
|
|
ListOfGO ExtractSubShapes (in GEOM_Object theShape,
|
|
|
|
|
in long theShapeType,
|
2010-11-18 17:14:05 +05:00
|
|
|
in boolean isSorted);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Deprecated method. Use GetAllSubShapesIDs() instead.
|
|
|
|
|
*/
|
|
|
|
|
ListOfLong SubShapeAllIDs (in GEOM_Object theShape,
|
2011-02-28 19:44:44 +05:00
|
|
|
in long theShapeType,
|
|
|
|
|
in boolean isSorted);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
2005-01-20 11:24:17 +05:00
|
|
|
/*!
|
|
|
|
|
* Explode a shape on subshapes of a given type.
|
2010-11-18 17:14:05 +05:00
|
|
|
* Does the same, as MakeAllSubShapes, but returns IDs of
|
|
|
|
|
* sub-shapes, not GEOM_Objects. It works faster.
|
2005-01-20 11:24:17 +05:00
|
|
|
* \param theShape Shape to be exploded.
|
|
|
|
|
* \param theShapeType Type of sub-shapes to be retrieved.
|
|
|
|
|
* \param isSorted If this parameter is TRUE, sub-shapes will be
|
|
|
|
|
* sorted by coordinates of their gravity centers.
|
|
|
|
|
* \return List of IDs of sub-shapes of type theShapeType, contained in theShape.
|
|
|
|
|
*/
|
2010-11-18 17:14:05 +05:00
|
|
|
ListOfLong GetAllSubShapesIDs (in GEOM_Object theShape,
|
|
|
|
|
in long theShapeType,
|
|
|
|
|
in boolean isSorted);
|
2005-01-20 11:24:17 +05:00
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Get a sub shape defined by its unique ID inside \a theMainShape
|
|
|
|
|
* \note The sub shape GEOM_Objects can has ONLY ONE function.
|
|
|
|
|
* Don't try to apply modification operations on them.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetSubShape (in GEOM_Object theMainShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in long theID);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
2006-05-06 14:44:32 +06:00
|
|
|
/*!
|
|
|
|
|
* Get global index of \a theSubShape in \a theMainShape.
|
|
|
|
|
* \param theMainShape Main shape.
|
|
|
|
|
* \param theSubShape Sub-shape of the main shape.
|
|
|
|
|
* \return global index of \a theSubShape in \a theMainShape.
|
|
|
|
|
*/
|
|
|
|
|
long GetSubShapeIndex (in GEOM_Object theMainShape, in GEOM_Object theSubShape);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get index of \a theSubShape in \a theMainShape, unique among sub-shapes of the same type.
|
|
|
|
|
* Together with method <VAR>GetShapeTypeString()</VAR> it can be used
|
|
|
|
|
* to generate automatic names for sub-shapes, when publishing them in a study.
|
|
|
|
|
* \param theMainShape Main shape.
|
|
|
|
|
* \param theSubShape Sub-shape of the main shape.
|
|
|
|
|
* \return index of \a theSubShape in a list of all sub-shapes of \a theMainShape of the same type.
|
|
|
|
|
*/
|
|
|
|
|
long GetTopologyIndex (in GEOM_Object theMainShape, in GEOM_Object theSubShape);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* \brief Get name of type of \a theShape.
|
|
|
|
|
*
|
|
|
|
|
* Use wide type notation, taking into consideration both topology and geometry of the shape.
|
|
|
|
|
* Together with method <VAR>GetTopologyIndex()</VAR> it can be used
|
|
|
|
|
* to generate automatic names for sub-shapes, when publishing them in a study.
|
|
|
|
|
* \param theShape The shape to get a type of.
|
|
|
|
|
* \return String, containing a type name of \a theShape.
|
|
|
|
|
*/
|
|
|
|
|
string GetShapeTypeString (in GEOM_Object theShape);
|
|
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Count number of faces in the given shape.
|
|
|
|
|
* \param theShape Shape to count faces in.
|
|
|
|
|
* \return Number of faces in the given shape.
|
|
|
|
|
*/
|
|
|
|
|
long NumberOfFaces (in GEOM_Object theShape);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Count number of edges in the given shape.
|
|
|
|
|
* \param theShape Shape to count edges in.
|
|
|
|
|
* \return Number of edges in theShape.
|
|
|
|
|
*/
|
|
|
|
|
long NumberOfEdges (in GEOM_Object theShape);
|
|
|
|
|
|
2009-05-27 17:46:05 +06:00
|
|
|
/*!
|
|
|
|
|
* Count number of subshapes of type \a theShapeType in the given shape.
|
|
|
|
|
* \param theShape Shape to count subshapes in.
|
|
|
|
|
* \param theShapeType The type of subshapes to count.
|
|
|
|
|
* \return Number of subshapes of type \a theShapeType in \a theShape.
|
|
|
|
|
*/
|
|
|
|
|
long NumberOfSubShapes (in GEOM_Object theShape,
|
|
|
|
|
in long theShapeType);
|
|
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Reverses an orientation the given shape.
|
|
|
|
|
* \param theShape Shape to be reversed.
|
|
|
|
|
* \return The reversed copy of theShape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object ChangeOrientation (in GEOM_Object theShape);
|
2005-01-20 11:24:17 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Retrieve all free faces from the given shape.
|
|
|
|
|
* Free face is a face, which is not shared between two shells of the shape.
|
|
|
|
|
* \param theShape Shape to find free faces in.
|
|
|
|
|
* \return List of IDs of all free faces, contained in theShape.
|
|
|
|
|
*/
|
|
|
|
|
ListOfLong GetFreeFacesIDs (in GEOM_Object theShape);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get all sub-shapes of theShape1 of the given type, shared with theShape2.
|
|
|
|
|
* \param theShape1 Shape to find sub-shapes in.
|
|
|
|
|
* \param theShape2 Shape to find shared sub-shapes with.
|
|
|
|
|
* \param theShapeType Type of sub-shapes to be retrieved.
|
|
|
|
|
* \return List of sub-shapes of theShape1, shared with theShape2.
|
|
|
|
|
*/
|
|
|
|
|
ListOfGO GetSharedShapes (in GEOM_Object theShape1,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theShape2,
|
|
|
|
|
in long theShapeType);
|
2005-01-20 11:24:17 +05:00
|
|
|
|
2010-11-18 17:14:05 +05:00
|
|
|
/*!
|
|
|
|
|
* Get all sub-shapes, shared by all shapes in the list \a theShapes.
|
|
|
|
|
* \param theShapes Shapes to find common sub-shapes of.
|
|
|
|
|
* \param theShapeType Type of sub-shapes to be retrieved.
|
|
|
|
|
* \return List of objects, that are sub-shapes of all given shapes.
|
|
|
|
|
*/
|
|
|
|
|
ListOfGO GetSharedShapesMulti (in ListOfGO theShapes,
|
|
|
|
|
in long theShapeType);
|
|
|
|
|
|
2005-01-20 11:24:17 +05:00
|
|
|
/*!
|
2005-01-21 14:16:41 +05:00
|
|
|
* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
|
|
|
|
|
* the specified plane by the certain way, defined through \a theState parameter.
|
2005-01-20 11:24:17 +05:00
|
|
|
* \param theShape Shape to find sub-shapes of.
|
|
|
|
|
* \param theShapeType Type of sub-shapes to be retrieved.
|
2005-01-21 14:16:41 +05:00
|
|
|
* \param theAx1 Vector (or line, or linear edge), specifying normal
|
|
|
|
|
* direction and location of the plane to find shapes on.
|
|
|
|
|
* \param theState The state of the subshapes to find.
|
|
|
|
|
* \return List of all found sub-shapes.
|
2005-01-20 11:24:17 +05:00
|
|
|
*/
|
2005-01-21 14:16:41 +05:00
|
|
|
ListOfGO GetShapesOnPlane (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in long theShapeType,
|
|
|
|
|
in GEOM_Object theAx1,
|
|
|
|
|
in shape_state theState);
|
2008-03-07 12:45:34 +05:00
|
|
|
/*!
|
|
|
|
|
* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
|
|
|
|
|
* the specified plane by the certain way, defined through \a theState parameter.
|
|
|
|
|
* \param theShape Shape to find sub-shapes of.
|
|
|
|
|
* \param theShapeType Type of sub-shapes to be retrieved.
|
|
|
|
|
* \param theAx1 Vector (or line, or linear edge), specifying normal
|
|
|
|
|
* direction of the plane to find shapes on.
|
|
|
|
|
* \param thePnt Point specifying location of the plane to find shapes on.
|
|
|
|
|
* \param theState The state of the subshapes to find.
|
|
|
|
|
* \return List of all found sub-shapes.
|
|
|
|
|
*/
|
|
|
|
|
ListOfGO GetShapesOnPlaneWithLocation (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in long theShapeType,
|
|
|
|
|
in GEOM_Object theAx1,
|
|
|
|
|
in GEOM_Object thePnt,
|
|
|
|
|
in shape_state theState);
|
2008-03-07 12:45:34 +05:00
|
|
|
|
|
|
|
|
|
2005-01-20 11:24:17 +05:00
|
|
|
|
|
|
|
|
/*!
|
2005-01-21 14:16:41 +05:00
|
|
|
* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
|
|
|
|
|
* the specified cylinder by the certain way, defined through \a theState parameter.
|
2005-01-20 11:24:17 +05:00
|
|
|
* \param theShape Shape to find sub-shapes of.
|
|
|
|
|
* \param theShapeType Type of sub-shapes to be retrieved.
|
|
|
|
|
* \param theAxis Vector (or line, or linear edge), specifying
|
|
|
|
|
* axis of the cylinder to find shapes on.
|
|
|
|
|
* \param theRadius Radius of the cylinder to find shapes on.
|
2005-01-21 14:16:41 +05:00
|
|
|
* \param theState The state of the subshapes to find.
|
|
|
|
|
* \return List of all found sub-shapes.
|
2005-01-20 11:24:17 +05:00
|
|
|
*/
|
2005-01-21 14:16:41 +05:00
|
|
|
ListOfGO GetShapesOnCylinder (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in long theShapeType,
|
|
|
|
|
in GEOM_Object theAxis,
|
|
|
|
|
in double theRadius,
|
|
|
|
|
in shape_state theState);
|
2005-01-20 11:24:17 +05:00
|
|
|
|
2009-12-28 12:41:33 +05:00
|
|
|
/*!
|
|
|
|
|
* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
|
|
|
|
|
* the specified cylinder by the certain way, defined through \a theState parameter.
|
|
|
|
|
* \param theShape Shape to find sub-shapes of.
|
|
|
|
|
* \param theShapeType Type of sub-shapes to be retrieved.
|
|
|
|
|
* \param theAxis Vector (or line, or linear edge), specifying
|
|
|
|
|
* axis of the cylinder to find shapes on.
|
|
|
|
|
* \param thePnt Point specifying location of the bottom of the cylinder.
|
|
|
|
|
* \param theRadius Radius of the cylinder to find shapes on.
|
|
|
|
|
* \param theState The state of the subshapes to find.
|
|
|
|
|
* \return List of all found sub-shapes.
|
|
|
|
|
*/
|
|
|
|
|
ListOfGO GetShapesOnCylinderWithLocation (in GEOM_Object theShape,
|
|
|
|
|
in long theShapeType,
|
|
|
|
|
in GEOM_Object theAxis,
|
|
|
|
|
in GEOM_Object thePnt,
|
|
|
|
|
in double theRadius,
|
|
|
|
|
in shape_state theState);
|
|
|
|
|
|
2005-01-20 11:24:17 +05:00
|
|
|
/*!
|
2005-01-21 14:16:41 +05:00
|
|
|
* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
|
|
|
|
|
* the specified sphere by the certain way, defined through \a theState parameter.
|
2005-01-20 11:24:17 +05:00
|
|
|
* \param theShape Shape to find sub-shapes of.
|
|
|
|
|
* \param theShapeType Type of sub-shapes to be retrieved.
|
|
|
|
|
* \param theCenter Point, specifying center of the sphere to find shapes on.
|
|
|
|
|
* \param theRadius Radius of the sphere to find shapes on.
|
2005-01-21 14:16:41 +05:00
|
|
|
* \param theState The state of the subshapes to find.
|
|
|
|
|
* \return List of all found sub-shapes.
|
|
|
|
|
*/
|
|
|
|
|
ListOfGO GetShapesOnSphere (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in long theShapeType,
|
|
|
|
|
in GEOM_Object theCenter,
|
|
|
|
|
in double theRadius,
|
|
|
|
|
in shape_state theState);
|
2005-01-20 11:24:17 +05:00
|
|
|
|
2005-10-14 19:30:58 +06:00
|
|
|
/*!
|
|
|
|
|
* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
|
|
|
|
|
* the specified quadrangle by the certain way, defined through \a theState parameter.
|
|
|
|
|
* \param theShape Shape to find sub-shapes of.
|
|
|
|
|
* \param theShapeType Type of sub-shapes to be retrieved.
|
|
|
|
|
* \param theTopLeftPoint Top left quadrangle corner
|
|
|
|
|
* \param theTopRigthPoint Top right quadrangle corner
|
|
|
|
|
* \param theBottomLeftPoint Bottom left quadrangle corner
|
|
|
|
|
* \param theBottomRigthPoint Bottom right quadrangle corner
|
|
|
|
|
* \param theState The state of the subshapes to find.
|
|
|
|
|
* \return List of all found sub-shapes.
|
|
|
|
|
*/
|
|
|
|
|
ListOfGO GetShapesOnQuadrangle (in GEOM_Object theShape,
|
|
|
|
|
in long theShapeType,
|
|
|
|
|
in GEOM_Object theTopLeftPoint,
|
|
|
|
|
in GEOM_Object theTopRigthPoint,
|
|
|
|
|
in GEOM_Object theBottomLeftPoint,
|
|
|
|
|
in GEOM_Object theBottomRigthPoint,
|
|
|
|
|
in shape_state theState);
|
|
|
|
|
|
2005-03-23 12:27:20 +05:00
|
|
|
/*!
|
|
|
|
|
* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
|
|
|
|
|
* the specified plane by the certain way, defined through \a theState parameter.
|
|
|
|
|
* \param theShape Shape to find sub-shapes of.
|
|
|
|
|
* \param theShapeType Type of sub-shapes to be retrieved.
|
|
|
|
|
* \param theAx1 Vector (or line, or linear edge), specifying normal
|
|
|
|
|
* direction and location of the plane to find shapes on.
|
|
|
|
|
* \param theState The state of the subshapes to find.
|
|
|
|
|
* \return List of IDs of all found sub-shapes.
|
|
|
|
|
*/
|
|
|
|
|
ListOfLong GetShapesOnPlaneIDs (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in long theShapeType,
|
|
|
|
|
in GEOM_Object theAx1,
|
|
|
|
|
in shape_state theState);
|
2009-02-13 17:16:39 +05:00
|
|
|
|
2008-03-07 12:45:34 +05:00
|
|
|
/*!
|
|
|
|
|
* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
|
|
|
|
|
* the specified plane by the certain way, defined through \a theState parameter.
|
|
|
|
|
* \param theShape Shape to find sub-shapes of.
|
|
|
|
|
* \param theShapeType Type of sub-shapes to be retrieved.
|
|
|
|
|
* \param theAx1 Vector (or line, or linear edge), specifying normal
|
|
|
|
|
* direction of the plane to find shapes on.
|
2009-02-13 17:16:39 +05:00
|
|
|
* \param thePnt Point specifying location of the plane to find shapes on.
|
2008-03-07 12:45:34 +05:00
|
|
|
* \param theState The state of the subshapes to find.
|
|
|
|
|
* \return List of IDs of all found sub-shapes.
|
|
|
|
|
*/
|
|
|
|
|
ListOfLong GetShapesOnPlaneWithLocationIDs (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in long theShapeType,
|
|
|
|
|
in GEOM_Object theAx1,
|
|
|
|
|
in GEOM_Object thePnt,
|
|
|
|
|
in shape_state theState);
|
2005-03-23 12:27:20 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
|
|
|
|
|
* the specified cylinder by the certain way, defined through \a theState parameter.
|
|
|
|
|
* \param theShape Shape to find sub-shapes of.
|
|
|
|
|
* \param theShapeType Type of sub-shapes to be retrieved.
|
|
|
|
|
* \param theAxis Vector (or line, or linear edge), specifying
|
|
|
|
|
* axis of the cylinder to find shapes on.
|
|
|
|
|
* \param theRadius Radius of the cylinder to find shapes on.
|
|
|
|
|
* \param theState The state of the subshapes to find.
|
|
|
|
|
* \return List of IDs of all found sub-shapes.
|
|
|
|
|
*/
|
|
|
|
|
ListOfLong GetShapesOnCylinderIDs (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in long theShapeType,
|
|
|
|
|
in GEOM_Object theAxis,
|
|
|
|
|
in double theRadius,
|
|
|
|
|
in shape_state theState);
|
2005-03-23 12:27:20 +05:00
|
|
|
|
2009-12-28 12:41:33 +05:00
|
|
|
/*!
|
|
|
|
|
* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
|
|
|
|
|
* the specified cylinder by the certain way, defined through \a theState parameter.
|
|
|
|
|
* \param theShape Shape to find sub-shapes of.
|
|
|
|
|
* \param theShapeType Type of sub-shapes to be retrieved.
|
|
|
|
|
* \param theAxis Vector (or line, or linear edge), specifying
|
|
|
|
|
* axis of the cylinder to find shapes on.
|
|
|
|
|
* \param thePnt Point specifying location of the bottom of the cylinder.
|
|
|
|
|
* \param theRadius Radius of the cylinder to find shapes on.
|
|
|
|
|
* \param theState The state of the subshapes to find.
|
|
|
|
|
* \return List of IDs all found sub-shapes.
|
|
|
|
|
*/
|
|
|
|
|
ListOfLong GetShapesOnCylinderWithLocationIDs (in GEOM_Object theShape,
|
|
|
|
|
in long theShapeType,
|
|
|
|
|
in GEOM_Object theAxis,
|
|
|
|
|
in GEOM_Object thePnt,
|
|
|
|
|
in double theRadius,
|
|
|
|
|
in shape_state theState);
|
|
|
|
|
|
2005-03-23 12:27:20 +05:00
|
|
|
/*!
|
|
|
|
|
* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
|
|
|
|
|
* the specified sphere by the certain way, defined through \a theState parameter.
|
|
|
|
|
* \param theShape Shape to find sub-shapes of.
|
|
|
|
|
* \param theShapeType Type of sub-shapes to be retrieved.
|
|
|
|
|
* \param theCenter Point, specifying center of the sphere to find shapes on.
|
|
|
|
|
* \param theRadius Radius of the sphere to find shapes on.
|
|
|
|
|
* \param theState The state of the subshapes to find.
|
|
|
|
|
* \return List of IDs of all found sub-shapes.
|
|
|
|
|
*/
|
|
|
|
|
ListOfLong GetShapesOnSphereIDs (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in long theShapeType,
|
|
|
|
|
in GEOM_Object theCenter,
|
|
|
|
|
in double theRadius,
|
|
|
|
|
in shape_state theState);
|
2005-03-23 12:27:20 +05:00
|
|
|
|
2005-10-14 19:30:58 +06:00
|
|
|
/*!
|
|
|
|
|
* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
|
|
|
|
|
* the specified quadrangle by the certain way, defined through \a theState parameter.
|
|
|
|
|
* \param theShape Shape to find sub-shapes of.
|
|
|
|
|
* \param theShapeType Type of sub-shapes to be retrieved.
|
|
|
|
|
* \param theTopLeftPoint Top left quadrangle corner
|
|
|
|
|
* \param theTopRigthPoint Top right quadrangle corner
|
|
|
|
|
* \param theBottomLeftPoint Bottom left quadrangle corner
|
|
|
|
|
* \param theBottomRigthPoint Bottom right quadrangle corner
|
|
|
|
|
* \param theState The state of the subshapes to find.
|
|
|
|
|
* \return List of IDs of all found sub-shapes.
|
|
|
|
|
*/
|
|
|
|
|
ListOfLong GetShapesOnQuadrangleIDs (in GEOM_Object theShape,
|
|
|
|
|
in long theShapeType,
|
|
|
|
|
in GEOM_Object theTopLeftPoint,
|
|
|
|
|
in GEOM_Object theTopRigthPoint,
|
|
|
|
|
in GEOM_Object theBottomLeftPoint,
|
|
|
|
|
in GEOM_Object theBottomRigthPoint,
|
|
|
|
|
in shape_state theState);
|
|
|
|
|
|
2005-01-20 11:24:17 +05:00
|
|
|
/*!
|
2008-03-07 12:45:34 +05:00
|
|
|
* \brief Find subshapes complying with given status
|
|
|
|
|
* \param theBox - the box to check state of subshapes against
|
|
|
|
|
* \param theShape - the shape to explore
|
|
|
|
|
* \param theShapeType - type of subshape of theShape
|
|
|
|
|
* \param theState - required state
|
|
|
|
|
* \return List of IDs of all found sub-shapes.
|
|
|
|
|
*/
|
|
|
|
|
ListOfLong GetShapesOnBoxIDs (in GEOM_Object theBox,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theShape,
|
|
|
|
|
in long theShapeType,
|
|
|
|
|
in shape_state theState);
|
2008-03-07 12:45:34 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* \brief Find subshapes complying with given status
|
|
|
|
|
* \param theBox - the box to check state of subshapes against
|
|
|
|
|
* \param theShape - the shape to explore
|
|
|
|
|
* \param theShapeType - type of subshape of theShape
|
|
|
|
|
* \param theState - required state
|
|
|
|
|
* \return List of all found sub-shapes.
|
|
|
|
|
*/
|
|
|
|
|
ListOfGO GetShapesOnBox (in GEOM_Object theBox,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theShape,
|
|
|
|
|
in long theShapeType,
|
|
|
|
|
in shape_state theState);
|
2008-03-07 12:45:34 +05:00
|
|
|
|
2009-02-13 17:16:39 +05:00
|
|
|
/*!
|
|
|
|
|
* \brief Find subshapes complying with given status
|
2010-02-19 17:16:11 +05:00
|
|
|
* \param theCheckShape - the shape to check state of subshapes against. It must be a solid.
|
2009-02-13 17:16:39 +05:00
|
|
|
* \param theShape - the shape to explore
|
|
|
|
|
* \param theShapeType - type of subshape of theShape
|
|
|
|
|
* \param theState - required state
|
|
|
|
|
* \return List of IDs of all found sub-shapes.
|
|
|
|
|
*/
|
|
|
|
|
ListOfLong GetShapesOnShapeIDs (in GEOM_Object theCheckShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theShape,
|
|
|
|
|
in short theShapeType,
|
|
|
|
|
in shape_state theState);
|
2009-02-13 17:16:39 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* \brief Find subshapes complying with given status
|
2010-02-19 17:16:11 +05:00
|
|
|
* \param theCheckShape - the shape to check state of subshapes against. It must be a solid.
|
2009-02-13 17:16:39 +05:00
|
|
|
* \param theShape - the shape to explore
|
|
|
|
|
* \param theShapeType - type of subshape of theShape
|
|
|
|
|
* \param theState - required state
|
|
|
|
|
* \return List of all found sub-shapes.
|
|
|
|
|
*/
|
|
|
|
|
ListOfGO GetShapesOnShape (in GEOM_Object theCheckShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theShape,
|
|
|
|
|
in short theShapeType,
|
|
|
|
|
in shape_state theState);
|
2009-02-13 17:16:39 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* \brief Find subshapes complying with given status
|
2010-02-19 17:16:11 +05:00
|
|
|
* \param theCheckShape - the shape to check state of subshapes against. It must be a solid.
|
2009-02-13 17:16:39 +05:00
|
|
|
* \param theShape - the shape to explore
|
|
|
|
|
* \param theShapeType - type of subshape of theShape
|
|
|
|
|
* \param theState - required state
|
|
|
|
|
* \return compound includes all found sub-shapes.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetShapesOnShapeAsCompound (in GEOM_Object theCheckShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theShape,
|
|
|
|
|
in short theShapeType,
|
|
|
|
|
in shape_state theState);
|
2009-02-13 17:16:39 +05:00
|
|
|
|
2008-03-07 12:45:34 +05:00
|
|
|
/*!
|
|
|
|
|
* Get sub-shape(s) of \a theShapeWhere, which are
|
2005-01-20 11:24:17 +05:00
|
|
|
* coincident with \a theShapeWhat or could be a part of it.
|
|
|
|
|
* \param theShapeWhere Shape to find sub-shapes of.
|
|
|
|
|
* \param theShapeWhat Shape, specifying what to find.
|
|
|
|
|
* \return Group of all found sub-shapes or a single found sub-shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetInPlace (in GEOM_Object theShapeWhere,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theShapeWhat);
|
2008-03-07 12:45:34 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get sub-shape(s) of \a theShapeWhere, which are
|
|
|
|
|
* coincident with \a theShapeWhat or could be a part of it.
|
|
|
|
|
*
|
|
|
|
|
* Implementation of this method is based on a saved history of an operation,
|
|
|
|
|
* produced \a theShapeWhere. The \a theShapeWhat must be among this operation's
|
|
|
|
|
* arguments (an argument shape or a sub-shape of an argument shape).
|
|
|
|
|
* The operation could be the Partition or one of boolean operations,
|
|
|
|
|
* performed on simple shapes (not on compounds).
|
|
|
|
|
*
|
|
|
|
|
* \param theShapeWhere Shape to find sub-shapes of.
|
|
|
|
|
* \param theShapeWhat Shape, specifying what to find.
|
|
|
|
|
* \return Group of all found sub-shapes or a single found sub-shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetInPlaceByHistory (in GEOM_Object theShapeWhere,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theShapeWhat);
|
2008-03-07 12:45:34 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get sub-shape of theShapeWhere, which are
|
|
|
|
|
* coincident with \a theShapeWhat that can either SOLID, FACE, EDGE or VERTEX.
|
|
|
|
|
* \param theShapeWhere Shape to find sub-shapes of.
|
|
|
|
|
* \param theShapeWhat Shape, specifying what to find.
|
|
|
|
|
* \return found sub-shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetSame (in GEOM_Object theShapeWhere,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theShapeWhat);
|
2004-12-01 15:39:14 +05:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* GEOM_IBlocksOperations: Interface for Blocks construction
|
|
|
|
|
* Face from points or edges, Block from faces,
|
|
|
|
|
* Blocks multi-translation and multi-rotation
|
|
|
|
|
*/
|
|
|
|
|
interface GEOM_IBlocksOperations : GEOM_IOperations
|
|
|
|
|
{
|
|
|
|
|
/*!
|
|
|
|
|
* Creation of blocks
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a quadrangle face from four edges. Order of Edges is not
|
|
|
|
|
* important. It is not necessary that edges share the same vertex.
|
|
|
|
|
* \param theEdge1,theEdge2,theEdge3,theEdge4 Edges for the face bound.
|
|
|
|
|
* \return New GEOM_Object, containing the created face.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeQuad (in GEOM_Object theEdge1,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theEdge2,
|
|
|
|
|
in GEOM_Object theEdge3,
|
|
|
|
|
in GEOM_Object theEdge4);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a quadrangle face on two edges.
|
|
|
|
|
* The missing edges will be built by creating the shortest ones.
|
|
|
|
|
* \param theEdge1,theEdge2 Two opposite edges for the face.
|
|
|
|
|
* \return New GEOM_Object, containing the created face.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeQuad2Edges (in GEOM_Object theEdge1,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theEdge2);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a quadrangle face with specified corners.
|
|
|
|
|
* The missing edges will be built by creating the shortest ones.
|
|
|
|
|
* \param thePnt1,thePnt2,thePnt3,thePnt4 Corner vertices for the face.
|
|
|
|
|
* \return New GEOM_Object, containing the created face.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeQuad4Vertices (in GEOM_Object thePnt1,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object thePnt2,
|
|
|
|
|
in GEOM_Object thePnt3,
|
|
|
|
|
in GEOM_Object thePnt4);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a hexahedral solid, bounded by the six given faces. Order of
|
|
|
|
|
* faces is not important. It is not necessary that Faces share the same edge.
|
|
|
|
|
* \param theFace1-theFace6 Faces for the hexahedral solid.
|
|
|
|
|
* \return New GEOM_Object, containing the created solid.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeHexa (in GEOM_Object theFace1,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theFace2,
|
|
|
|
|
in GEOM_Object theFace3,
|
|
|
|
|
in GEOM_Object theFace4,
|
|
|
|
|
in GEOM_Object theFace5,
|
|
|
|
|
in GEOM_Object theFace6);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a hexahedral solid between two given faces.
|
|
|
|
|
* The missing faces will be built by creating the smallest ones.
|
|
|
|
|
* \param theFace1,theFace2 Two opposite faces for the hexahedral solid.
|
|
|
|
|
* \return New GEOM_Object, containing the created solid.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeHexa2Faces (in GEOM_Object theFace1,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theFace2);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Extract elements of blocks and blocks compounds
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get a vertex, found in the given shape by its coordinates.
|
|
|
|
|
* \param theShape Block or a compound of blocks.
|
|
|
|
|
* \param theX,theY,theZ Coordinates of the sought vertex.
|
|
|
|
|
* \param theEpsilon Maximum allowed distance between the resulting
|
|
|
|
|
* vertex and point with the given coordinates.
|
|
|
|
|
* \return New GEOM_Object, containing the found vertex.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetPoint (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theX,
|
|
|
|
|
in double theY,
|
|
|
|
|
in double theZ,
|
|
|
|
|
in double theEpsilon);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Find a vertex of the given shape, which has minimal distance to the given point.
|
|
|
|
|
* \param theShape Any shape.
|
|
|
|
|
* \param thePoint Point, close to the desired vertex.
|
|
|
|
|
* \return New GEOM_Object, containing the found vertex.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetVertexNearPoint (in GEOM_Object theShape,
|
|
|
|
|
in GEOM_Object thePoint);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get an edge, found in the given shape by two given vertices.
|
|
|
|
|
* \param theShape Block or a compound of blocks.
|
|
|
|
|
* \param thePoint1,thePoint2 Points, close to the ends of the desired edge.
|
|
|
|
|
* \return New GEOM_Object, containing the found edge.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetEdge (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object thePoint1,
|
|
|
|
|
in GEOM_Object thePoint2);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Find an edge of the given shape, which has minimal distance to the given point.
|
|
|
|
|
* \param theShape Block or a compound of blocks.
|
|
|
|
|
* \param thePoint Point, close to the desired edge.
|
|
|
|
|
* \return New GEOM_Object, containing the found edge.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetEdgeNearPoint (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object thePoint);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Returns a face, found in the given shape by four given corner vertices.
|
|
|
|
|
* \param theShape Block or a compound of blocks.
|
|
|
|
|
* \param thePoint1-thePoint4 Points, close to the corners of the desired face.
|
|
|
|
|
* \return New GEOM_Object, containing the found face.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetFaceByPoints (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object thePoint1,
|
|
|
|
|
in GEOM_Object thePoint2,
|
|
|
|
|
in GEOM_Object thePoint3,
|
|
|
|
|
in GEOM_Object thePoint4);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get a face of block, found in the given shape by two given edges.
|
|
|
|
|
* \param theShape Block or a compound of blocks.
|
|
|
|
|
* \param theEdge1,theEdge2 Edges, close to the edges of the desired face.
|
|
|
|
|
* \return New GEOM_Object, containing the found face.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetFaceByEdges (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theEdge1,
|
|
|
|
|
in GEOM_Object theEdge2);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Find a face, opposite to the given one in the given block.
|
|
|
|
|
* \param theBlock Must be a hexahedral solid.
|
|
|
|
|
* \param theFace Face of \a theBlock, opposite to the desired face.
|
|
|
|
|
* \return New GEOM_Object, containing the found face.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetOppositeFace (in GEOM_Object theBlock,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theFace);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Find a face of the given shape, which has minimal distance to the given point.
|
|
|
|
|
* \param theShape Block or a compound of blocks.
|
|
|
|
|
* \param thePoint Point, close to the desired face.
|
|
|
|
|
* \return New GEOM_Object, containing the found face.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetFaceNearPoint (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object thePoint);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Find a face of block, whose outside normale has minimal angle with the given vector.
|
|
|
|
|
* \param theShape Block or a compound of blocks.
|
|
|
|
|
* \param theVector Vector, close to the normale of the desired face.
|
|
|
|
|
* \return New GEOM_Object, containing the found face.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetFaceByNormale (in GEOM_Object theBlock,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theVector);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Find all subshapes of type \a theShapeType of the given shape,
|
|
|
|
|
* which have minimal distance to the given point.
|
|
|
|
|
* \param theShape Any shape.
|
|
|
|
|
* \param thePoint Point, close to the desired shape.
|
|
|
|
|
* \param theShapeType Defines what kind of subshapes is searched.
|
|
|
|
|
* \param theTolerance The tolerance for distances comparison. All shapes
|
|
|
|
|
* with distances to the given point in interval
|
|
|
|
|
* [minimal_distance, minimal_distance + theTolerance] will be gathered.
|
|
|
|
|
* \return New GEOM_Object, containing a group of all found shapes.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetShapesNearPoint (in GEOM_Object theShape,
|
|
|
|
|
in GEOM_Object thePoint,
|
|
|
|
|
in long theShapeType,
|
|
|
|
|
in double theTolerance);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Extract blocks from blocks compounds
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Check, if the compound contains only specified blocks.
|
|
|
|
|
* \param theCompound The compound to check.
|
|
|
|
|
* \param theMinNbFaces If solid has lower number of faces, it is not a block.
|
|
|
|
|
* \param theMaxNbFaces If solid has higher number of faces, it is not a block.
|
|
|
|
|
* \note If theMaxNbFaces = 0, the maximum number of faces is not restricted.
|
|
|
|
|
* \return TRUE, if the given compound contains only blocks.
|
|
|
|
|
* \return theNbBlocks Number of specified blocks in theCompound.
|
|
|
|
|
*/
|
|
|
|
|
boolean IsCompoundOfBlocks (in GEOM_Object theCompound,
|
2010-11-25 17:31:41 +05:00
|
|
|
in long theMinNbFaces,
|
|
|
|
|
in long theMaxNbFaces,
|
|
|
|
|
out long theNbBlocks);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Enumeration of Blocks Compound defects.
|
|
|
|
|
*/
|
|
|
|
|
enum BCErrorType
|
|
|
|
|
{
|
2005-01-20 11:24:17 +05:00
|
|
|
/* Each element of the compound should be a Block */
|
|
|
|
|
NOT_BLOCK,
|
|
|
|
|
|
|
|
|
|
/* An element is a potential block, but has degenerated and/or seam edge(s). */
|
|
|
|
|
EXTRA_EDGE,
|
|
|
|
|
|
|
|
|
|
/* A connection between two Blocks should be an entire face or an entire edge */
|
|
|
|
|
INVALID_CONNECTION,
|
|
|
|
|
|
|
|
|
|
/* The compound should be connexe */
|
|
|
|
|
NOT_CONNECTED,
|
|
|
|
|
|
|
|
|
|
/* The glue between two quadrangle faces should be applied */
|
|
|
|
|
NOT_GLUED
|
2004-12-01 15:39:14 +05:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Description of Blocks Compound defect: type and incriminated sub-shapes.
|
|
|
|
|
*/
|
|
|
|
|
struct BCError
|
|
|
|
|
{
|
|
|
|
|
BCErrorType error;
|
|
|
|
|
ListOfLong incriminated;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Sequence of all Blocks Compound defects.
|
|
|
|
|
*/
|
|
|
|
|
typedef sequence<BCError> BCErrors;
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Check, if the compound of blocks is given.
|
|
|
|
|
* To be considered as a compound of blocks, the
|
|
|
|
|
* given shape must satisfy the following conditions:
|
|
|
|
|
* - Each element of the compound should be a Block (6 faces and 12 edges).
|
|
|
|
|
* - A connection between two Blocks should be an entire quadrangle face or an entire edge.
|
|
|
|
|
* - The compound should be connexe.
|
|
|
|
|
* - The glue between two quadrangle faces should be applied.
|
2005-01-20 11:24:17 +05:00
|
|
|
* \note Single block is also accepted as a valid compound of blocks.
|
2004-12-01 15:39:14 +05:00
|
|
|
* \param theCompound The compound to check.
|
|
|
|
|
* \return TRUE, if the given shape is a compound of blocks.
|
|
|
|
|
* \return theErrors Structure, containing discovered errors and incriminated sub-shapes.
|
|
|
|
|
*/
|
|
|
|
|
boolean CheckCompoundOfBlocks (in GEOM_Object theCompound,
|
2010-11-25 17:31:41 +05:00
|
|
|
out BCErrors theErrors);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Convert sequence of Blocks Compound errors, returned by
|
|
|
|
|
* <VAR>CheckCompoundOfBlocks()</VAR>, into string.
|
|
|
|
|
* \param theCompound The bad compound.
|
|
|
|
|
* \param theErrors The sequence of \a theCompound errors.
|
|
|
|
|
* \return String, describing all the errors in form, suitable for printing.
|
|
|
|
|
*/
|
|
|
|
|
string PrintBCErrors (in GEOM_Object theCompound,
|
2010-11-25 17:31:41 +05:00
|
|
|
in BCErrors theErrors);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
2005-01-20 11:24:17 +05:00
|
|
|
/*!
|
|
|
|
|
* Remove all seam and degenerated edges from \a theShape.
|
|
|
|
|
* Unite faces and edges, sharing one surface.
|
|
|
|
|
* \param theShape The compound or single solid to remove irregular edges from.
|
2009-04-21 19:28:59 +06:00
|
|
|
* \param theOptimumNbFaces If more than zero, unite faces only for those solids,
|
|
|
|
|
* that have more than theOptimumNbFaces faces. If zero, unite faces always,
|
|
|
|
|
* regardsless their quantity in the solid. If negative, do not unite faces at all.
|
|
|
|
|
* For blocks repairing recommended value is 6.
|
2005-01-20 11:24:17 +05:00
|
|
|
* \return Improved shape.
|
|
|
|
|
*/
|
2009-04-21 19:28:59 +06:00
|
|
|
GEOM_Object RemoveExtraEdges (in GEOM_Object theShape,
|
|
|
|
|
in long theOptimumNbFaces);
|
2005-01-20 11:24:17 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Check, if the given shape is a blocks compound.
|
|
|
|
|
* Fix all detected errors.
|
|
|
|
|
* \note Single block can be also fixed by this method.
|
|
|
|
|
* \param theCompound The compound to check and improve.
|
|
|
|
|
* \return Improved compound.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object CheckAndImprove (in GEOM_Object theCompound);
|
|
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Get all the blocks, contained in the given compound.
|
|
|
|
|
* \param theCompound The compound to explode.
|
|
|
|
|
* \param theMinNbFaces If solid has lower number of faces, it is not a block.
|
|
|
|
|
* \param theMaxNbFaces If solid has higher number of faces, it is not a block.
|
|
|
|
|
* \note If theMaxNbFaces = 0, the maximum number of faces is not restricted.
|
|
|
|
|
* \return List of GEOM_Objects, containing the retrieved blocks.
|
|
|
|
|
*/
|
|
|
|
|
ListOfGO ExplodeCompoundOfBlocks (in GEOM_Object theCompound,
|
2010-11-25 17:31:41 +05:00
|
|
|
in long theMinNbFaces,
|
|
|
|
|
in long theMaxNbFaces);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Find block, containing the given point inside its volume or on boundary.
|
|
|
|
|
* \param theCompound Compound, to find block in.
|
|
|
|
|
* \param thePoint Point, close to the desired block. If the point lays on
|
|
|
|
|
* boundary between some blocks, we return block with nearest center.
|
|
|
|
|
* \return New GEOM_Object, containing the found block.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetBlockNearPoint (in GEOM_Object theCompound,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object thePoint);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Find block, containing all the elements, passed as the parts, or maximum quantity of them.
|
|
|
|
|
* \param theCompound Compound, to find block in.
|
|
|
|
|
* \param theParts List of faces and/or edges and/or vertices to be parts of the found block.
|
|
|
|
|
* \return New GEOM_Object, containing the found block.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetBlockByParts (in GEOM_Object theCompound,
|
2010-11-25 17:31:41 +05:00
|
|
|
in ListOfGO theParts);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Return all blocks, containing all the elements, passed as the parts.
|
|
|
|
|
* \param theCompound Compound, to find blocks in.
|
|
|
|
|
* \param theParts List of faces and/or edges and/or vertices to be parts of the found blocks.
|
|
|
|
|
* \return List of GEOM_Objects, containing the found blocks.
|
|
|
|
|
*/
|
|
|
|
|
ListOfGO GetBlocksByParts (in GEOM_Object theCompound,
|
2010-11-25 17:31:41 +05:00
|
|
|
in ListOfGO theParts);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Operations on blocks with gluing of result
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Multi-transformate block and glue the result.
|
|
|
|
|
* Transformation is defined so, as to superpose theDirFace1 with theDirFace2.
|
|
|
|
|
* \param theBlock Hexahedral solid to be multi-transformed.
|
|
|
|
|
* \param theDirFace1 First direction face global index.
|
|
|
|
|
* \param theDirFace2 Second direction face global index.
|
|
|
|
|
* \param theNbTimes Quantity of transformations to be done.
|
|
|
|
|
* \note Global index of sub-shape can be obtained, using method
|
2006-05-06 14:44:32 +06:00
|
|
|
* <VAR>GEOM_IShapesOperations.GetSubShapeIndex()</VAR>.
|
2004-12-01 15:39:14 +05:00
|
|
|
* \return New GEOM_Object, containing the result shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeMultiTransformation1D (in GEOM_Object theBlock,
|
2010-11-25 17:31:41 +05:00
|
|
|
in long theDirFace1,
|
|
|
|
|
in long theDirFace2,
|
|
|
|
|
in long theNbTimes);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Multi-transformate block and glue the result.
|
|
|
|
|
* \param theBlock Hexahedral solid to be multi-transformed.
|
|
|
|
|
* \param theDirFace1U,theDirFace2U Direction faces for the first transformation.
|
|
|
|
|
* \param theDirFace1V,theDirFace2V Direction faces for the second transformation.
|
|
|
|
|
* \param theNbTimesU,theNbTimesV Quantity of transformations to be done.
|
|
|
|
|
* \return New GEOM_Object, containing the result shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeMultiTransformation2D (in GEOM_Object theBlock,
|
2010-11-25 17:31:41 +05:00
|
|
|
in long theDirFace1U,
|
|
|
|
|
in long theDirFace2U,
|
|
|
|
|
in long theNbTimesU,
|
|
|
|
|
in long theDirFace1V,
|
|
|
|
|
in long theDirFace2V,
|
|
|
|
|
in long theNbTimesV);
|
2005-01-20 11:24:17 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Special operation - propagation
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Build all possible propagation groups.
|
|
|
|
|
* Propagation group is a set of all edges, opposite to one (main)
|
|
|
|
|
* edge of this group directly or through other opposite edges.
|
|
|
|
|
* Notion of Opposite Edge make sence only on quadrangle face.
|
|
|
|
|
* \param theShape Shape to build propagation groups on.
|
|
|
|
|
* \return List of GEOM_Objects, each of them is a propagation group.
|
|
|
|
|
*/
|
|
|
|
|
ListOfGO Propagate (in GEOM_Object theShape);
|
2004-12-01 15:39:14 +05:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* GEOM_IBooleanOperations: Interface for boolean operations (Cut, Fuse, Common)
|
|
|
|
|
*/
|
|
|
|
|
interface GEOM_IBooleanOperations : GEOM_IOperations
|
|
|
|
|
{
|
|
|
|
|
/*!
|
|
|
|
|
* Perform one of boolean operations on two given shapes.
|
|
|
|
|
* \param theShape1 First argument for boolean operation.
|
|
|
|
|
* \param theShape2 Second argument for boolean operation.
|
|
|
|
|
* \param theOperation Indicates the operation to be done:
|
|
|
|
|
* 1 - Common, 2 - Cut, 3 - Fuse, 4 - Section.
|
|
|
|
|
* \return New GEOM_Object, containing the result shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeBoolean (in GEOM_Object theShape1,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theShape2,
|
|
|
|
|
in long theOperation);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Perform partition operation.
|
|
|
|
|
* \param theShapes Shapes to be intersected.
|
|
|
|
|
* \param theTools Shapes to intersect theShapes.
|
2008-03-07 12:45:34 +05:00
|
|
|
* \note Each compound from ListShapes and ListTools will be exploded in order
|
|
|
|
|
* to avoid possible intersection between shapes from this compound.
|
|
|
|
|
* \param theLimit Type of resulting shapes (corresponding to TopAbs_ShapeEnum).
|
2010-06-10 14:25:12 +06:00
|
|
|
* \param KeepNonlimitShapes: if this parameter == 0, then only shapes of
|
|
|
|
|
* target type (equal to Limit) are kept in the result,
|
|
|
|
|
* else standalone shapes of lower dimension
|
|
|
|
|
* are kept also (if they exist).
|
2008-03-07 12:45:34 +05:00
|
|
|
*
|
|
|
|
|
* After implementation new version of PartitionAlgo (October 2006)
|
|
|
|
|
* other parameters are ignored by current functionality. They are kept
|
|
|
|
|
* in this function only for supporting old versions.
|
|
|
|
|
* Ignored parameters:
|
2004-12-01 15:39:14 +05:00
|
|
|
* \param theKeepInside Shapes, outside which the results will be deleted.
|
|
|
|
|
* Each shape from theKeepInside must belong to theShapes also.
|
|
|
|
|
* \param theRemoveInside Shapes, inside which the results will be deleted.
|
|
|
|
|
* Each shape from theRemoveInside must belong to theShapes also.
|
|
|
|
|
* \param theRemoveWebs If TRUE, perform Glue 3D algorithm.
|
|
|
|
|
* \param theMaterials Material indices for each shape. Make sence, only if theRemoveWebs is TRUE.
|
2008-03-07 12:45:34 +05:00
|
|
|
*
|
2004-12-01 15:39:14 +05:00
|
|
|
* \return New GEOM_Object, containing the result shapes.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePartition (in ListOfGO theShapes,
|
2010-11-25 17:31:41 +05:00
|
|
|
in ListOfGO theTools,
|
|
|
|
|
in ListOfGO theKeepInside,
|
|
|
|
|
in ListOfGO theRemoveInside,
|
|
|
|
|
in short theLimit,
|
|
|
|
|
in boolean theRemoveWebs,
|
|
|
|
|
in ListOfLong theMaterials,
|
|
|
|
|
in short theKeepNonlimitShapes);
|
2008-03-07 12:45:34 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Perform partition operation.
|
|
|
|
|
* This method may be usefull if it is needed to make a partition for
|
|
|
|
|
* a compound containing nonintersected shapes. Performance will be better
|
|
|
|
|
* since intersection between shapes from compound is not performed.
|
|
|
|
|
*
|
|
|
|
|
* Description of all parameters as in previous method MakePartition()
|
|
|
|
|
*
|
|
|
|
|
* \note Passed compounds (via ListShapes or via ListTools)
|
|
|
|
|
* have to consist of nonintersecting shapes.
|
|
|
|
|
*
|
|
|
|
|
* \return New GEOM_Object, containing the result shapes.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePartitionNonSelfIntersectedShape (in ListOfGO theShapes,
|
2010-11-25 17:31:41 +05:00
|
|
|
in ListOfGO theTools,
|
|
|
|
|
in ListOfGO theKeepInside,
|
|
|
|
|
in ListOfGO theRemoveInside,
|
|
|
|
|
in short theLimit,
|
|
|
|
|
in boolean theRemoveWebs,
|
|
|
|
|
in ListOfLong theMaterials,
|
|
|
|
|
in short theKeepNonlimitShapes);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Perform partition of the Shape with the Plane
|
|
|
|
|
* \param theShape Shape to be intersected.
|
|
|
|
|
* \param thePlane Tool shape, to intersect theShape.
|
|
|
|
|
* \return New GEOM_Object, containing the result shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeHalfPartition (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object thePlane);
|
2004-12-01 15:39:14 +05:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* GEOM_ICurvesOperations: Interface for curves creation.
|
|
|
|
|
* Polyline, Circle, Spline (Bezier and Interpolation)
|
|
|
|
|
*/
|
|
|
|
|
interface GEOM_ICurvesOperations : GEOM_IOperations
|
|
|
|
|
{
|
|
|
|
|
/*!
|
|
|
|
|
* Create a circle with given center, normal vector and radius.
|
|
|
|
|
* \param thePnt Circle center.
|
|
|
|
|
* \param theVec Vector, normal to the plane of the circle.
|
|
|
|
|
* \param theR Circle radius.
|
|
|
|
|
* \return New GEOM_Object, containing the created circle.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeCirclePntVecR (in GEOM_Object thePnt,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theVec,
|
|
|
|
|
in double theR);
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Create a circle, passing through three given points
|
|
|
|
|
* \param thePnt1,thePnt2,thePnt3 Points, defining the circle.
|
|
|
|
|
* \return New GEOM_Object, containing the created circle.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeCircleThreePnt (in GEOM_Object thePnt1,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object thePnt2,
|
|
|
|
|
in GEOM_Object thePnt3);
|
2008-03-07 12:45:34 +05:00
|
|
|
/*!
|
|
|
|
|
* Create a circle with given center, with a radius equals the distance from center to Point1
|
|
|
|
|
* and on a plane defined by all of three points.
|
|
|
|
|
* \param thePnt1,thePnt2,thePnt3 Points, defining the circle.
|
|
|
|
|
* \return New GEOM_Object, containing the created circle.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeCircleCenter2Pnt (in GEOM_Object thePnt1,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object thePnt2,
|
|
|
|
|
in GEOM_Object thePnt3);
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Create an ellipse with given center, normal vector and radiuses.
|
|
|
|
|
* \param thePnt Ellipse center.
|
|
|
|
|
* \param theVec Vector, normal to the plane of the ellipse.
|
|
|
|
|
* \param theRMajor Major ellipse radius.
|
|
|
|
|
* \param theRMinor Minor ellipse radius.
|
|
|
|
|
* \return New GEOM_Object, containing the created ellipse.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeEllipse (in GEOM_Object thePnt,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theVec,
|
|
|
|
|
in double theRMajor,
|
|
|
|
|
in double theRMinor);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
2009-02-25 18:31:16 +05:00
|
|
|
/*!
|
|
|
|
|
* Create an ellipse with given center, normal vector, main axis vector and radiuses.
|
|
|
|
|
* \param thePnt Ellipse center.
|
|
|
|
|
* \param theVec Vector, normal to the plane of the ellipse.
|
|
|
|
|
* \param theRMajor Major ellipse radius.
|
|
|
|
|
* \param theRMinor Minor ellipse radius.
|
|
|
|
|
* \param theVecMaj Vector, direction of the ellipse's main axis.
|
|
|
|
|
* \return New GEOM_Object, containing the created ellipse.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeEllipseVec (in GEOM_Object thePnt,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theVec,
|
|
|
|
|
in double theRMajor,
|
|
|
|
|
in double theRMinor,
|
|
|
|
|
in GEOM_Object theVecMaj);
|
2009-02-25 18:31:16 +05:00
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Create an arc of circle, passing through three given points.
|
|
|
|
|
* \param thePnt1 Start point of the arc.
|
|
|
|
|
* \param thePnt2 Middle point of the arc.
|
|
|
|
|
* \param thePnt3 End point of the arc.
|
|
|
|
|
* \return New GEOM_Object, containing the created arc.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeArc (in GEOM_Object thePnt1,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object thePnt2,
|
|
|
|
|
in GEOM_Object thePnt3);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
2008-03-07 12:45:34 +05:00
|
|
|
/*!
|
|
|
|
|
* Create an arc of circle of center C from one point to another
|
|
|
|
|
* \param theCenter Center point of the arc.
|
|
|
|
|
* \param thePnt1 Start point of the arc.
|
|
|
|
|
* \param thePnt2 End point of the arc.
|
|
|
|
|
* \param theSense Orientation of the arc
|
|
|
|
|
* \return New GEOM_Object, containing the created arc.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeArcCenter (in GEOM_Object theCenter,
|
|
|
|
|
in GEOM_Object thePnt1,
|
|
|
|
|
in GEOM_Object thePnt2,
|
|
|
|
|
in boolean theSense);
|
2009-12-08 17:05:55 +05:00
|
|
|
|
2009-02-13 17:16:39 +05:00
|
|
|
/*!
|
|
|
|
|
* Create an arc of ellipse of center C and two points P1 P2.
|
|
|
|
|
* \param theCenter Center point of the arc.
|
|
|
|
|
* \param thePnt1 Major radius is distance from center to Pnt1.
|
2011-02-28 19:44:44 +05:00
|
|
|
* \param thePnt2 define a plane and Minor radius as a shortest
|
|
|
|
|
* distance from Pnt2 to vector Center->Pnt1.
|
2009-02-13 17:16:39 +05:00
|
|
|
* \return New GEOM_Object, containing the created arc.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeArcOfEllipse (in GEOM_Object theCenter,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object thePnt1,
|
|
|
|
|
in GEOM_Object thePnt2);
|
2008-03-07 12:45:34 +05:00
|
|
|
|
|
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Create a polyline on the set of points.
|
|
|
|
|
* \param thePoints Sequence of points for the polyline.
|
|
|
|
|
* \return New GEOM_Object, containing the created polyline.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakePolyline (in ListOfGO thePoints);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create bezier curve on the set of points.
|
|
|
|
|
* \param thePoints Sequence of points for the bezier curve.
|
|
|
|
|
* \return New GEOM_Object, containing the created bezier curve.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeSplineBezier (in ListOfGO thePoints);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create B-Spline curve on the set of points.
|
|
|
|
|
* \param thePoints Sequence of points for the B-Spline curve.
|
2009-08-25 18:37:33 +06:00
|
|
|
* \param theIsClosed If TRUE, build a closed curve.
|
2004-12-01 15:39:14 +05:00
|
|
|
* \return New GEOM_Object, containing the created B-Spline curve.
|
|
|
|
|
*/
|
2009-08-25 18:37:33 +06:00
|
|
|
GEOM_Object MakeSplineInterpolation (in ListOfGO thePoints,
|
|
|
|
|
in boolean theIsClosed);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a sketcher (wire or face), following the textual description,
|
|
|
|
|
* passed through \a theCommand argument. \n
|
|
|
|
|
* Edges of the resulting wire or face will be arcs of circles and/or linear segments. \n
|
|
|
|
|
* Format of the description string have to be the following:
|
|
|
|
|
*
|
|
|
|
|
* "Sketcher[:F x1 y1]:CMD[:CMD[:CMD...]]"
|
|
|
|
|
*
|
|
|
|
|
* Where:
|
|
|
|
|
* - x1, y1 are coordinates of the first sketcher point (zero by default),
|
|
|
|
|
* - CMD is one of
|
|
|
|
|
* - "R angle" : Set the direction by angle
|
|
|
|
|
* - "D dx dy" : Set the direction by DX & DY
|
|
|
|
|
* .
|
|
|
|
|
* \n
|
|
|
|
|
* - "TT x y" : Create segment by point at X & Y
|
|
|
|
|
* - "T dx dy" : Create segment by point with DX & DY
|
|
|
|
|
* - "L length" : Create segment by direction & Length
|
|
|
|
|
* - "IX x" : Create segment by direction & Intersect. X
|
|
|
|
|
* - "IY y" : Create segment by direction & Intersect. Y
|
|
|
|
|
* .
|
|
|
|
|
* \n
|
|
|
|
|
* - "C radius length" : Create arc by direction, radius and length(in degree)
|
|
|
|
|
* .
|
|
|
|
|
* \n
|
|
|
|
|
* - "WW" : Close Wire (to finish)
|
|
|
|
|
* - "WF" : Close Wire and build face (to finish)
|
|
|
|
|
*
|
|
|
|
|
* \param theCommand String, defining the sketcher in local
|
|
|
|
|
* coordinates of the working plane.
|
|
|
|
|
* \param theWorkingPlane Nine double values, defining origin,
|
|
|
|
|
* OZ and OX directions of the working plane.
|
|
|
|
|
* \return New GEOM_Object, containing the created wire.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeSketcher (in string theCommand, in ListOfDouble theWorkingPlane);
|
2009-12-08 17:05:55 +05:00
|
|
|
|
2009-02-13 17:16:39 +05:00
|
|
|
/*!
|
|
|
|
|
* Create a 3D sketcher, following the numerical description,
|
|
|
|
|
* passed through points created by \a theCoordinates argument. \n
|
|
|
|
|
* Format of the description string have to be the following:
|
|
|
|
|
*
|
|
|
|
|
* "Make3DSketcher[x1, y1, z1, x2, y2, z2, ..., xN, yN, zN]"
|
|
|
|
|
*/
|
2009-12-08 17:05:55 +05:00
|
|
|
|
2009-02-13 17:16:39 +05:00
|
|
|
GEOM_Object Make3DSketcher (in ListOfDouble theCoordinates);
|
2005-06-20 11:57:52 +06:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Create a sketcher (wire or face), following the textual description,
|
|
|
|
|
* passed through \a theCommand argument. \n
|
|
|
|
|
* For format of the description string see the previous method.\n
|
|
|
|
|
* \param theCommand String, defining the sketcher in local
|
|
|
|
|
* coordinates of the working plane.
|
2008-03-07 12:45:34 +05:00
|
|
|
* \param theWorkingPlane Planar Face or LCS(Marker) of the working plane.
|
2005-06-20 11:57:52 +06:00
|
|
|
* \return New GEOM_Object, containing the created wire.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeSketcherOnPlane (in string theCommand, in GEOM_Object theWorkingPlane);
|
2004-12-01 15:39:14 +05:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* GEOM_ILocalOperations: Interface for fillet and chamfer creation.
|
|
|
|
|
*/
|
|
|
|
|
interface GEOM_ILocalOperations : GEOM_IOperations
|
|
|
|
|
{
|
|
|
|
|
/*!
|
|
|
|
|
* Perform a fillet on all edges of the given shape.
|
|
|
|
|
* \param theShape Shape, to perform fillet on.
|
|
|
|
|
* \param theR Fillet radius.
|
|
|
|
|
* \return New GEOM_Object, containing the result shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeFilletAll (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theR);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Perform a fillet on the specified edges of the given shape
|
|
|
|
|
* \param theShape Shape, to perform fillet on.
|
|
|
|
|
* \param theR Fillet radius.
|
|
|
|
|
* \param theEdges Global indices of edges to perform fillet on.
|
2006-05-06 14:44:32 +06:00
|
|
|
* \note Global index of sub-shape can be obtained, using method
|
|
|
|
|
* <VAR>GEOM_IShapesOperations.GetSubShapeIndex()</VAR>.
|
2004-12-01 15:39:14 +05:00
|
|
|
* \return New GEOM_Object, containing the result shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeFilletEdges (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theR,
|
|
|
|
|
in ListOfLong theEdges);
|
2008-03-07 12:45:34 +05:00
|
|
|
GEOM_Object MakeFilletEdgesR1R2 (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theR1,
|
|
|
|
|
in double theR2,
|
|
|
|
|
in ListOfLong theEdges);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Perform a fillet on all edges of the specified faces of the given shape.
|
|
|
|
|
* \param theShape Shape, to perform fillet on.
|
|
|
|
|
* \param theR Fillet radius.
|
|
|
|
|
* \param theFaces Global indices of faces to perform fillet on.
|
2006-05-06 14:44:32 +06:00
|
|
|
* \note Global index of sub-shape can be obtained, using method
|
|
|
|
|
* <VAR>GEOM_IShapesOperations.GetSubShapeIndex()</VAR>.
|
2004-12-01 15:39:14 +05:00
|
|
|
* \return New GEOM_Object, containing the result shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeFilletFaces (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theR,
|
|
|
|
|
in ListOfLong theFaces);
|
2009-12-08 17:05:55 +05:00
|
|
|
|
2008-03-07 12:45:34 +05:00
|
|
|
GEOM_Object MakeFilletFacesR1R2 (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theR1,
|
|
|
|
|
in double theR2,
|
|
|
|
|
in ListOfLong theFaces);
|
2009-12-08 17:05:55 +05:00
|
|
|
|
2009-02-13 17:16:39 +05:00
|
|
|
/*!
|
|
|
|
|
* Perform a fillet on face of the specified vertexes of the given shape.
|
|
|
|
|
* \param theShape Shape, to perform fillet on.
|
|
|
|
|
* \param theR Fillet radius.
|
|
|
|
|
* \param theVertexes Global indices of vertexes to perform fillet on.
|
|
|
|
|
* \note Global index of sub-shape can be obtained, using method
|
|
|
|
|
* <VAR>GEOM_IShapesOperations.GetSubShapeIndex()</VAR>.
|
|
|
|
|
* \return New GEOM_Object, containing the result shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeFillet2D (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theR,
|
|
|
|
|
in ListOfLong theVertexes);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
2009-08-18 17:15:10 +06:00
|
|
|
/*!
|
|
|
|
|
* Perform a fillet on edges of the specified vertexes of the given wire.
|
|
|
|
|
* \param theShape Shape, to perform fillet on.
|
|
|
|
|
* \param theR Fillet radius.
|
|
|
|
|
* \param theVertexes Global indices of vertexes to perform fillet on.
|
|
|
|
|
* \note Global index of sub-shape can be obtained, using method
|
|
|
|
|
* <VAR>GEOM_IShapesOperations.GetSubShapeIndex()</VAR>.
|
|
|
|
|
* \note The list of vertices coudl be empty, in this case fillet fill be done
|
|
|
|
|
* at all vertices in given wire
|
|
|
|
|
* \return New GEOM_Object, containing the result shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeFillet1D (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theR,
|
|
|
|
|
in ListOfLong theVertexes);
|
2009-08-18 17:15:10 +06:00
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Perform a symmetric chamfer on all edges of the given shape.
|
|
|
|
|
* \param theShape Shape, to perform chamfer on.
|
|
|
|
|
* \param theD Chamfer size along each face.
|
|
|
|
|
* \return New GEOM_Object, containing the result shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeChamferAll (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theD);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Perform a chamfer on edges, common to the specified faces.
|
|
|
|
|
* with distance D1 on the Face1
|
|
|
|
|
* \param theShape Shape, to perform chamfer on.
|
|
|
|
|
* \param theD1 Chamfer size along \a theFace1.
|
|
|
|
|
* \param theD2 Chamfer size along \a theFace2.
|
|
|
|
|
* \param theFace1,theFace2 Global indices of two faces of \a theShape.
|
2006-05-06 14:44:32 +06:00
|
|
|
* \note Global index of sub-shape can be obtained, using method
|
|
|
|
|
* <VAR>GEOM_IShapesOperations.GetSubShapeIndex()</VAR>.
|
2004-12-01 15:39:14 +05:00
|
|
|
* \return New GEOM_Object, containing the result shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeChamferEdge (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theD1, in double theD2,
|
|
|
|
|
in long theFace1, in long theFace2);
|
2009-02-13 17:16:39 +05:00
|
|
|
/*!
|
2008-03-07 12:45:34 +05:00
|
|
|
* The Same but with params theD = Chamfer Lenght
|
|
|
|
|
* and theAngle = Chamfer Angle (Angle in radians)
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeChamferEdgeAD (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theD, in double theAngle,
|
|
|
|
|
in long theFace1, in long theFace2);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Perform a chamfer on all edges of the specified faces.
|
|
|
|
|
* with distance D1 on the first specified face (if several for one edge)
|
|
|
|
|
* \param theShape Shape, to perform chamfer on.
|
|
|
|
|
* \param theD1 Chamfer size along face from \a theFaces. If both faces,
|
|
|
|
|
* connected to the edge, are in \a theFaces, \a theD1
|
|
|
|
|
* will be get along face, which is nearer to \a theFaces beginning.
|
|
|
|
|
* \param theD2 Chamfer size along another of two faces, connected to the edge.
|
|
|
|
|
* \param theFaces Sequence of global indices of faces of \a theShape.
|
2006-05-06 14:44:32 +06:00
|
|
|
* \note Global index of sub-shape can be obtained, using method
|
|
|
|
|
* <VAR>GEOM_IShapesOperations.GetSubShapeIndex()</VAR>.
|
2004-12-01 15:39:14 +05:00
|
|
|
* \return New GEOM_Object, containing the result shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeChamferFaces (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theD1, in double theD2,
|
|
|
|
|
in ListOfLong theFaces);
|
2009-02-13 17:16:39 +05:00
|
|
|
/*!
|
2008-03-07 12:45:34 +05:00
|
|
|
* The Same but with params theD = Chamfer Lenght
|
|
|
|
|
* and theAngle = Chamfer Angle (Angle in radians)
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeChamferFacesAD (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theD, in double theAngle,
|
|
|
|
|
in ListOfLong theFaces);
|
2008-03-07 12:45:34 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Perform a chamfer on edges,
|
|
|
|
|
* with distance D1 on the first specified face (if several for one edge)
|
|
|
|
|
* \param theShape Shape, to perform chamfer on.
|
|
|
|
|
* \param theD1 theD2 Chamfer size
|
|
|
|
|
* \param theEdges Sequence of edges of \a theShape.
|
|
|
|
|
* \return New GEOM_Object, containing the result shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeChamferEdges (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theD1, in double theD2,
|
|
|
|
|
in ListOfLong theEdges);
|
2009-02-13 17:16:39 +05:00
|
|
|
/*!
|
2008-03-07 12:45:34 +05:00
|
|
|
* The Same but with params theD = Chamfer Lenght
|
|
|
|
|
* and theAngle = Chamfer Angle (Angle in radians)
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeChamferEdgesAD (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theD, in double theAngle,
|
|
|
|
|
in ListOfLong theEdges);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Perform an Archimde operation on the given shape with given parameters.
|
|
|
|
|
* The object presenting the resulting face is returned
|
|
|
|
|
* \param theShape Shape to be put in water.
|
|
|
|
|
* \param theWeight Weight og the shape.
|
|
|
|
|
* \param theWaterDensity Density of the water.
|
|
|
|
|
* \param theMeshDeflection Deflection od the mesh, using to compute the section.
|
|
|
|
|
* \return New GEOM_Object, containing a section of \a theShape
|
|
|
|
|
* by a plane, corresponding to water level.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeArchimede (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theWeight,
|
|
|
|
|
in double theWaterDensity,
|
|
|
|
|
in double theMeshDeflection);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
2006-05-06 14:44:32 +06:00
|
|
|
* Duplicates <VAR>GEOM_IShapesOperations.GetSubShapeIndex()</VAR>.
|
|
|
|
|
* Present here only for compatibility.
|
2004-12-01 15:39:14 +05:00
|
|
|
*/
|
|
|
|
|
long GetSubShapeIndex (in GEOM_Object theShape, in GEOM_Object theSubShape);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* GEOM_IHealingOperations: Interface for shape healing operations.
|
|
|
|
|
* Shape Processing, SuppressFaces, etc.
|
|
|
|
|
*/
|
|
|
|
|
interface GEOM_IHealingOperations : GEOM_IOperations
|
|
|
|
|
{
|
|
|
|
|
/*!
|
|
|
|
|
* Apply a sequence of Shape Healing operators to the given object.
|
|
|
|
|
* \param theShapes Shape to be processed.
|
|
|
|
|
* \param theOperators List of names of operators ("FixShape", "SplitClosedFaces", etc.).
|
|
|
|
|
* \param theParameters List of names of parameters
|
|
|
|
|
* ("FixShape.Tolerance3d", "SplitClosedFaces.NbSplitPoints", etc.).
|
|
|
|
|
* \param theValues List of values of parameters, in the same order
|
|
|
|
|
* as parameters are listed in \a theParameters list.
|
|
|
|
|
* \return New GEOM_Object, containing processed shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object ProcessShape (in GEOM_Object theShapes,
|
2010-11-25 17:31:41 +05:00
|
|
|
in string_array theOperators,
|
|
|
|
|
in string_array theParameters,
|
|
|
|
|
in string_array theValues);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get default sequence of operators, their parameters and parameters' values
|
|
|
|
|
* of Shape Process operation. In the current implementation the defaults are
|
|
|
|
|
* read from the file pointed by CSF_ShHealingDefaults environmental variable.
|
|
|
|
|
* \param theOperators Output. Default list of names of operators.
|
|
|
|
|
* \param theParameters Output. Default list of names of parameters.
|
|
|
|
|
* \param theValues Output. List of default values of parameters, in the same order
|
|
|
|
|
* as parameters are listed in \a theParameters list.
|
|
|
|
|
*/
|
|
|
|
|
void GetShapeProcessParameters (out string_array theOperators,
|
2010-11-25 17:31:41 +05:00
|
|
|
out string_array theParameters,
|
|
|
|
|
out string_array theValues);
|
2005-01-24 21:00:40 +05:00
|
|
|
/*!
|
|
|
|
|
* Get parameters and parameters' values for the given Shape Process operation.
|
|
|
|
|
* In the current implementation the defaults are
|
|
|
|
|
* read from the file pointed by CSF_ShHealingDefaults environmental variable.
|
|
|
|
|
* \param theOperator Input. The operator's name.
|
|
|
|
|
* \param theParameters Output. Default list of names of parameters.
|
|
|
|
|
* \param theValues Output. List of default values of parameters, in the same order
|
|
|
|
|
* as parameters are listed in \a theParameters list.
|
|
|
|
|
*/
|
|
|
|
|
void GetOperatorParameters (in string theOperator,
|
2010-11-25 17:31:41 +05:00
|
|
|
out string_array theParameters,
|
|
|
|
|
out string_array theValues);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Remove faces from the given object (shape).
|
|
|
|
|
* \param theObject Shape to be processed.
|
|
|
|
|
* \param theFaces Indices of faces to be removed, if EMPTY then the method
|
|
|
|
|
* removes ALL faces of the given object.
|
|
|
|
|
* \return New GEOM_Object, containing processed shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object SuppressFaces (in GEOM_Object theObject, in short_array theFaces);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Close an open wire.
|
|
|
|
|
* \param theObject Shape to be processed.
|
|
|
|
|
* \param theWires Indexes of edge(s) and wire(s) to be closed within <VAR>theObject</VAR>'s shape,
|
|
|
|
|
* if -1, then theObject itself is a wire.
|
|
|
|
|
* \param isCommonVertex If TRUE : closure by creation of a common vertex,
|
|
|
|
|
* If FALS : closure by creation of an edge between ends.
|
|
|
|
|
* \return New GEOM_Object, containing processed shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object CloseContour (in GEOM_Object theObject, in short_array theWires,
|
2010-11-25 17:31:41 +05:00
|
|
|
in boolean isCommonVertex);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Remove internal wires and edges from the given object (face).
|
|
|
|
|
* \param theObject Shape to be processed.
|
|
|
|
|
* \param theWires Indices of wires to be removed, if EMPTY then the method
|
|
|
|
|
* removes ALL internal wires of the given object.
|
|
|
|
|
* \return New GEOM_Object, containing processed shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object RemoveIntWires (in GEOM_Object theObject, in short_array theWires);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Remove internal closed contours (holes) from the given object.
|
|
|
|
|
* \param theObject Shape to be processed.
|
|
|
|
|
* \param theWires Indices of wires to be removed, if EMPTY then the method
|
|
|
|
|
* removes ALL internal holes of the given object
|
|
|
|
|
* \return New GEOM_Object, containing processed shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object FillHoles (in GEOM_Object theObject, in short_array theWires);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Sewing of the given object.
|
|
|
|
|
* \param theObject Shape to be processed.
|
|
|
|
|
* \param theTolerance Required tolerance value.
|
|
|
|
|
* \return New GEOM_Object, containing processed shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object Sew (in GEOM_Object theObject, in double theTolerance);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Addition of a point to a given edge object.
|
|
|
|
|
* \param theObject Shape to be processed.
|
|
|
|
|
* \param theEdgeIndex Index of edge to be divided within theObject's shape,
|
|
|
|
|
* if -1, then theObject itself is the edge.
|
|
|
|
|
* \param theValue Value of parameter on edge or length parameter,
|
|
|
|
|
* depending on \a isByParameter.
|
|
|
|
|
* \param isByParameter If TRUE : \a theValue is treated as a curve parameter [0..1],
|
|
|
|
|
* if FALSE : \a theValue is treated as a length parameter [0..1]
|
|
|
|
|
* \return New GEOM_Object, containing processed shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object DivideEdge (in GEOM_Object theObject, in short theEdgeIndex,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theValue, in boolean isByParameter);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get a list of wires (wrapped in GEOM_Object-s),
|
|
|
|
|
* that constitute a free boundary of the given shape.
|
|
|
|
|
* \param theObject Shape to get free boundary of.
|
|
|
|
|
* \param theClosedWires Output. Closed wires on the free boundary of the given shape.
|
|
|
|
|
* \param theOpenWires Output. Open wires on the free boundary of the given shape.
|
|
|
|
|
* \return FALSE, if an error(s) occured during the method execution.
|
|
|
|
|
*/
|
|
|
|
|
boolean GetFreeBoundary (in GEOM_Object theObject,
|
2010-11-25 17:31:41 +05:00
|
|
|
out ListOfGO theClosedWires,
|
|
|
|
|
out ListOfGO theOpenWires);
|
2008-03-07 12:45:34 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Change orientation of the given object.
|
|
|
|
|
* \param theObject Shape to be processed.
|
|
|
|
|
* \return New GEOM_Object, containing processed shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object ChangeOrientation (in GEOM_Object theObject);
|
|
|
|
|
GEOM_Object ChangeOrientationCopy (in GEOM_Object theObject);
|
|
|
|
|
|
2010-11-25 17:31:41 +05:00
|
|
|
/*!
|
|
|
|
|
* Try to limit tolerance of the given object by value \a theTolerance.
|
|
|
|
|
* \param theObject Shape to be processed.
|
|
|
|
|
* \param theTolerance Required tolerance value.
|
|
|
|
|
* \return New GEOM_Object, containing processed shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object LimitTolerance (in GEOM_Object theObject, in double theTolerance);
|
|
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* GEOM_IInsertOperations: Interface for shape insert operations (like copy, import).
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
interface GEOM_IInsertOperations : GEOM_IOperations
|
|
|
|
|
{
|
|
|
|
|
/*!
|
|
|
|
|
* Create a copy of the given object
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object MakeCopy (in GEOM_Object theOriginal);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Export the given shape into a file with given name.
|
|
|
|
|
* \param theObject Shape to be stored in the file.
|
|
|
|
|
* \param theFileName Name of the file to store the given shape in.
|
|
|
|
|
* \param theFormatName Specify format for the shape storage.
|
|
|
|
|
* Available formats can be obtained with <VAR>ImportTranslators()</VAR> method.
|
|
|
|
|
*/
|
|
|
|
|
void Export (in GEOM_Object theObject, in string theFileName, in string theFormatName);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Import a shape from the BRep or IGES or STEP file
|
|
|
|
|
* (depends on given format) with given name.
|
|
|
|
|
* \param theFileName The file, containing the shape.
|
|
|
|
|
* \param theFormatName Specify format for the file reading.
|
|
|
|
|
* Available formats can be obtained with <VAR>ImportTranslators()</VAR> method.
|
2009-06-03 13:17:42 +06:00
|
|
|
* If format 'IGES_SCALE' is used instead 'IGES' length unit will be
|
|
|
|
|
* set to 'meter' and result model will be scaled.
|
2004-12-01 15:39:14 +05:00
|
|
|
* \return New GEOM_Object, containing the imported shape.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object Import (in string theFileName, in string theFormatName);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get the supported import formats and corresponding patterns for File dialog.
|
|
|
|
|
* \param theFormats Output. List of formats, available for import.
|
|
|
|
|
* \param thePatterns Output. List of file patterns, corresponding to available formats.
|
|
|
|
|
* \return Returns available formats and patterns through the arguments.
|
|
|
|
|
*/
|
|
|
|
|
void ImportTranslators (out string_array theFormats,
|
2010-11-25 17:31:41 +05:00
|
|
|
out string_array thePatterns);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get the supported export formats and corresponding patterns for File dialog.
|
|
|
|
|
* \param theFormats Output. List of formats, available for export.
|
|
|
|
|
* \param thePatterns Output. List of file patterns, corresponding to available formats.
|
|
|
|
|
* \return Returns available formats and patterns through the arguments.
|
|
|
|
|
*/
|
|
|
|
|
void ExportTranslators (out string_array theFormats,
|
2010-11-25 17:31:41 +05:00
|
|
|
out string_array thePatterns);
|
2009-12-08 17:05:55 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Load texture from file
|
|
|
|
|
* \param theTextureFile texture file name
|
|
|
|
|
* \return unique texture identifier
|
|
|
|
|
*/
|
|
|
|
|
long LoadTexture(in string theTextureFile);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Add texture to the study
|
|
|
|
|
* \param theWidth texture width in pixels
|
|
|
|
|
* \param theHeight texture height in pixels
|
|
|
|
|
* \param theTexture texture byte array
|
|
|
|
|
* \return unique texture identifier
|
|
|
|
|
*/
|
|
|
|
|
long AddTexture(in long theWidth, in long theHeight, in SALOMEDS::TMPFile theTexture);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get previously loaded texture data
|
|
|
|
|
* \param theID texture identifier
|
|
|
|
|
* \param theWidth texture width in pixels
|
|
|
|
|
* \param theHeight texture height in pixels
|
|
|
|
|
* \return texture byte array
|
|
|
|
|
*/
|
|
|
|
|
SALOMEDS::TMPFile GetTexture(in long theID, out long theWidth, out long theHeight);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get list of all avaiable texture IDs
|
|
|
|
|
* \return list of all texture IDs avaiable for the current study
|
|
|
|
|
*/
|
|
|
|
|
ListOfLong GetAllTextures();
|
2004-12-01 15:39:14 +05:00
|
|
|
};
|
|
|
|
|
|
2008-03-07 12:45:34 +05:00
|
|
|
/*!
|
|
|
|
|
* GEOM_IKindOfShape: namespace for shape_kind enumeration.
|
|
|
|
|
*/
|
|
|
|
|
interface GEOM_IKindOfShape
|
|
|
|
|
{
|
|
|
|
|
enum shape_kind {
|
|
|
|
|
NO_SHAPE,
|
|
|
|
|
// COMPOSITEs
|
|
|
|
|
COMPOUND,
|
|
|
|
|
COMPSOLID,
|
|
|
|
|
SHELL,
|
|
|
|
|
WIRE,
|
|
|
|
|
// SOLIDs
|
|
|
|
|
SPHERE, // full sphere
|
|
|
|
|
CYLINDER, // cylinder
|
|
|
|
|
BOX, // box with faces, parallel to global coordinate planes
|
|
|
|
|
ROTATED_BOX, // other box
|
|
|
|
|
TORUS, // full torus
|
|
|
|
|
CONE, // cone
|
|
|
|
|
POLYHEDRON, // solid, bounded by polygons
|
|
|
|
|
SOLID, // other solid
|
|
|
|
|
// FACEs
|
|
|
|
|
SPHERE2D, // spherical face (closed)
|
|
|
|
|
CYLINDER2D, // cylindrical face with defined height
|
|
|
|
|
TORUS2D, // toroidal face (closed)
|
|
|
|
|
CONE2D, // conical face with defined height
|
|
|
|
|
DISK_CIRCLE, // planar, bounded by circle
|
|
|
|
|
DISK_ELLIPSE, // planar, bounded by ellipse
|
|
|
|
|
POLYGON, // planar, bounded by segments
|
|
|
|
|
PLANE, // infinite planar
|
|
|
|
|
PLANAR, // other planar
|
|
|
|
|
FACE, // other face
|
|
|
|
|
// EDGEs
|
|
|
|
|
CIRCLE, // full circle
|
|
|
|
|
ARC_CIRCLE, // arc of circle
|
|
|
|
|
ELLIPSE, // full ellipse
|
|
|
|
|
ARC_ELLIPSE, // arc of ellipse
|
|
|
|
|
LINE, // infinite segment
|
|
|
|
|
SEGMENT, // segment
|
|
|
|
|
EDGE, // other edge
|
|
|
|
|
// VERTEX
|
2010-05-14 21:15:28 +06:00
|
|
|
VERTEX,
|
|
|
|
|
// ADVANCED shapes
|
|
|
|
|
ADVANCED // all advanced shapes (temporary implementation)
|
2008-03-07 12:45:34 +05:00
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* GEOM_IMeasureOperations: Interface for measurement (distance, whatis) and
|
|
|
|
|
* properties calculation (like Centre of Mass, Inertia, etc.).
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
interface GEOM_IMeasureOperations : GEOM_IOperations
|
|
|
|
|
{
|
2008-03-07 12:45:34 +05:00
|
|
|
/*!
|
|
|
|
|
* Get kind of theShape.
|
|
|
|
|
* \param theShape Shape to get a kind of.
|
|
|
|
|
* \param theIntegers Output. Integer and enumerated shape's parameters
|
|
|
|
|
* (kind of surface, closed/unclosed, number of edges, etc.)
|
|
|
|
|
* \param theDoubles Output. Double shape's parameters (coordinates, dimensions, etc.)
|
|
|
|
|
* \note Concrete meaning of each value, returned via \a theIntegers
|
|
|
|
|
* or \a theDoubles list depends on the kind of the shape.
|
|
|
|
|
* \return Returns a kind of shape in terms of <VAR>GEOM_IKindOfShape.shape_kind</VAR> enumeration.
|
|
|
|
|
*/
|
|
|
|
|
//short KindOfShape (in GEOM_Object theShape,
|
|
|
|
|
GEOM_IKindOfShape::shape_kind KindOfShape (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
out ListOfLong theIntegers,
|
|
|
|
|
out ListOfDouble theDoubles);
|
2008-03-07 12:45:34 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get position (LCS) of theShape.
|
|
|
|
|
* \param theShape Shape to calculate position of.
|
|
|
|
|
* \param Ox,Oy,Oz Output. Coordinates of shape's location origin.
|
|
|
|
|
* Origin of the LCS is situated at the shape's center of mass.
|
|
|
|
|
* \param Zx,Zy,Zz Output. Coordinates of shape's location normal(main) direction.
|
|
|
|
|
* \param Xx,Xy,Xz Output. Coordinates of shape's location X direction.
|
|
|
|
|
* Axes of the LCS are obtained from shape's location or,
|
|
|
|
|
* if the shape is a planar face, from position of its plane.
|
|
|
|
|
* \return Returns position of the shape through the last nine arguments.
|
|
|
|
|
*/
|
|
|
|
|
void GetPosition (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
out double Ox, out double Oy, out double Oz,
|
|
|
|
|
out double Zx, out double Zy, out double Zz,
|
|
|
|
|
out double Xx, out double Xy, out double Xz);
|
2008-03-07 12:45:34 +05:00
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Get summarized length of all wires,
|
|
|
|
|
* area of surface and volume of the given shape.
|
|
|
|
|
* \param theShape Shape to define properties of.
|
|
|
|
|
* \param theLength Output. Summarized length of all wires of the given shape.
|
|
|
|
|
* \param theSurfArea Output. Area of surface of the given shape.
|
|
|
|
|
* \param theVolume Output. Volume of the given shape.
|
|
|
|
|
* \return Returns shape properties through the last three arguments.
|
|
|
|
|
*/
|
|
|
|
|
void GetBasicProperties (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
out double theLength,
|
|
|
|
|
out double theSurfArea,
|
|
|
|
|
out double theVolume);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get a point, situated at the centre of mass of theShape.
|
|
|
|
|
* \param theShape Shape to define centre of mass of.
|
|
|
|
|
* \return New GEOM_Object, containing the created point.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetCentreOfMass (in GEOM_Object theShape);
|
2010-11-25 17:31:41 +05:00
|
|
|
|
2010-02-12 19:43:44 +05:00
|
|
|
/*
|
|
|
|
|
* Get the vertex by index for 1D objects depends the edge/wire orientation
|
|
|
|
|
* \param theShape Shape (wire or edge) to find the vertex on it
|
|
|
|
|
* \param theIndex Index of vertex subshape
|
|
|
|
|
* \return New GEOM_Object, vertex.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetVertexByIndex( in GEOM_Object theShape, in long index );
|
2004-12-01 15:39:14 +05:00
|
|
|
|
2008-03-07 12:45:34 +05:00
|
|
|
/*!
|
|
|
|
|
* Get a vector, representing the normal of theFace.
|
|
|
|
|
* If the face is not planar, theOptionalPoint is obligatory.
|
|
|
|
|
* \param theFace Shape (face) to define the normal of.
|
|
|
|
|
* \param theOptionalPoint Shape (point) to define the normal at.
|
|
|
|
|
* Can be NULL in case of planar face.
|
|
|
|
|
* \return New GEOM_Object, containing the created normal vector.
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetNormal (in GEOM_Object theFace,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theOptionalPoint);
|
2008-03-07 12:45:34 +05:00
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Get inertia matrix and moments of inertia of theShape.
|
|
|
|
|
* \param theShape Shape to calculate inertia of.
|
|
|
|
|
* \param I(1-3)(1-3) Output. Components of the inertia matrix of the given shape.
|
|
|
|
|
* \param Ix,Iy,Iz Output. Moments of inertia of the given shape.
|
|
|
|
|
* \return Returns inertia through the last twelve arguments.
|
|
|
|
|
*/
|
|
|
|
|
void GetInertia (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
out double I11, out double I12, out double I13,
|
|
|
|
|
out double I21, out double I22, out double I23,
|
|
|
|
|
out double I31, out double I32, out double I33,
|
|
|
|
|
out double Ix , out double Iy , out double Iz);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get parameters of bounding box of the given shape
|
|
|
|
|
* \param theShape Shape to obtain bounding box of.
|
|
|
|
|
* \param Xmin,Xmax Output. Limits of shape along OX axis.
|
|
|
|
|
* \param Ymin,Ymax Output. Limits of shape along OY axis.
|
|
|
|
|
* \param Zmin,Zmax Output. Limits of shape along OZ axis.
|
|
|
|
|
* \return Returns parameters of bounding box through the last six arguments.
|
|
|
|
|
*/
|
|
|
|
|
void GetBoundingBox (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
out double Xmin, out double Xmax,
|
|
|
|
|
out double Ymin, out double Ymax,
|
|
|
|
|
out double Zmin, out double Zmax);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get min and max tolerances of sub-shapes of theShape
|
|
|
|
|
* \param theShape Shape, to get tolerances of.
|
|
|
|
|
* \param FaceMin,FaceMax Output. Min and max tolerances of the faces.
|
|
|
|
|
* \param EdgeMin,EdgeMax Output. Min and max tolerances of the edges.
|
|
|
|
|
* \param VertMin,VertMax Output. Min and max tolerances of the vertices.
|
|
|
|
|
* \return Returns shape tolerances through the last six arguments.
|
|
|
|
|
*/
|
|
|
|
|
void GetTolerance (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
out double FaceMin, out double FaceMax,
|
|
|
|
|
out double EdgeMin, out double EdgeMax,
|
|
|
|
|
out double VertMin, out double VertMax);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Check a topology of the given shape.
|
|
|
|
|
* \param theShape Shape to check validity of.
|
|
|
|
|
* \param theDescription Output. Description of problems in the shape, if they are.
|
|
|
|
|
* \return TRUE, if the shape "seems to be valid" from the topological point of view.
|
|
|
|
|
*/
|
|
|
|
|
boolean CheckShape (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
out string theDescription);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
2008-03-07 12:45:34 +05:00
|
|
|
/*!
|
|
|
|
|
* Check a topology and a geometry of the given shape.
|
|
|
|
|
* \param theShape Shape to check validity of.
|
|
|
|
|
* \param theDescription Output. Description of problems in the shape, if they are.
|
|
|
|
|
* \return TRUE, if the shape "seems to be valid".
|
|
|
|
|
*/
|
|
|
|
|
boolean CheckShapeWithGeometry (in GEOM_Object theShape,
|
2010-11-25 17:31:41 +05:00
|
|
|
out string theDescription);
|
2008-03-07 12:45:34 +05:00
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Obtain description of the given shape
|
|
|
|
|
* \param theShape Shape to be described.
|
|
|
|
|
* \return Description of the given shape.
|
|
|
|
|
*/
|
|
|
|
|
string WhatIs (in GEOM_Object theShape);
|
|
|
|
|
|
2011-02-18 12:55:09 +05:00
|
|
|
/*!
|
|
|
|
|
* Check if points defined by coords = [x1, y1, z1, x2, y2, z2, ...] are inside or on
|
|
|
|
|
* the shape theShape.
|
|
|
|
|
* \param theShape Shape to check.
|
|
|
|
|
* \param coords list of coordinates.
|
|
|
|
|
* \param tolerance tolerance.
|
|
|
|
|
* \return list of boolean.
|
|
|
|
|
*/
|
|
|
|
|
ListOfBool AreCoordsInside(in GEOM_Object theShape, in ListOfDouble coords, in double tolerance);
|
|
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Get minimal distance between the given shapes.
|
|
|
|
|
* \param theShape1,theShape2 Shapes to find minimal distance between.
|
|
|
|
|
* \param X1,Y1,Z1 Output. Coordinates of point on theShape1, nearest to theShape2.
|
|
|
|
|
* \param X2,Y2,Z2 Output. Coordinates of point on theShape2, nearest to theShape1.
|
|
|
|
|
* \return Value of the minimal distance between the given shapes.
|
|
|
|
|
*/
|
|
|
|
|
double GetMinDistance (in GEOM_Object theShape1, in GEOM_Object theShape2,
|
2010-11-25 17:31:41 +05:00
|
|
|
out double X1, out double Y1, out double Z1,
|
|
|
|
|
out double X2, out double Y2, out double Z2);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
2008-03-07 12:45:34 +05:00
|
|
|
/*!
|
|
|
|
|
* Get angle between the given lines or linear edges.
|
|
|
|
|
* \param theShape1,theShape2 Shapes to find angle between. Lines or linear edges.
|
|
|
|
|
* \return Value of the angle between the given shapes.
|
|
|
|
|
*/
|
|
|
|
|
double GetAngle (in GEOM_Object theShape1, in GEOM_Object theShape2);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get point coordinates
|
|
|
|
|
*/
|
|
|
|
|
void PointCoordinates (in GEOM_Object theShape, out double X, out double Y, out double Z);
|
2009-02-13 17:16:39 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get radius of curvature of curve in the point determinated by param
|
|
|
|
|
* \param theShape - curve.
|
|
|
|
|
* \param theParam - parameter on curve
|
|
|
|
|
* \return Value of curvature.
|
|
|
|
|
*/
|
|
|
|
|
double CurveCurvatureByParam (in GEOM_Object theShape, in double theParam);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get radius of curvature of curve in the given point
|
|
|
|
|
* \param theShape - curve.
|
|
|
|
|
* \param thePoint - point
|
|
|
|
|
* \return Value of curvature.
|
|
|
|
|
*/
|
|
|
|
|
double CurveCurvatureByPoint (in GEOM_Object theShape, in GEOM_Object thePoint);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get max radius of curvature of surface in the point determinated by params
|
|
|
|
|
* \param theShape - surface.
|
|
|
|
|
* \param theUParam - U-parameter on surface
|
|
|
|
|
* \param theVParam - V-parameter on surface
|
|
|
|
|
* \return Value of curvature.
|
|
|
|
|
*/
|
|
|
|
|
double MaxSurfaceCurvatureByParam (in GEOM_Object theShape, in double theUParam,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theVParam);
|
2009-02-13 17:16:39 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get max radius of curvature of surface in the given point
|
|
|
|
|
* \param theShape - surface.
|
|
|
|
|
* \param thePoint - point
|
|
|
|
|
* \return Value of curvature.
|
|
|
|
|
*/
|
|
|
|
|
double MaxSurfaceCurvatureByPoint (in GEOM_Object theShape, in GEOM_Object thePoint);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get min radius of curvature of surface in the point determinated by params
|
|
|
|
|
* \param theShape - surface.
|
|
|
|
|
* \param theUParam - U-parameter on surface
|
|
|
|
|
* \param theVParam - V-parameter on surface
|
|
|
|
|
* \return Value of curvature.
|
|
|
|
|
*/
|
|
|
|
|
double MinSurfaceCurvatureByParam (in GEOM_Object theShape, in double theUParam,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theVParam);
|
2009-02-13 17:16:39 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Get min radius of curvature of surface in the given point
|
|
|
|
|
* \param theShape - surface.
|
|
|
|
|
* \param thePoint - point
|
|
|
|
|
* \return Value of curvature.
|
|
|
|
|
*/
|
|
|
|
|
double MinSurfaceCurvatureByPoint (in GEOM_Object theShape, in GEOM_Object thePoint);
|
|
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* GEOM_IGroupOperations: Interface for groups creation.
|
|
|
|
|
*/
|
|
|
|
|
interface GEOM_IGroupOperations : GEOM_IOperations
|
|
|
|
|
{
|
|
|
|
|
/*!
|
|
|
|
|
* Creates a new group which will store sub shapes of theMainShape
|
|
|
|
|
* \param theMainShape is a GEOM object on which the group is selected
|
|
|
|
|
* \param theShapeType defines a shape type of the group
|
|
|
|
|
* \return a newly created GEOM group
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object CreateGroup (in GEOM_Object theMainShape, in long theShapeType);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Adds a sub object with ID theSubShapeId to the group
|
|
|
|
|
* \param theGroup is a GEOM group to which the new sub shape is added
|
|
|
|
|
* \param theSubShapeId is a sub shape ID in the main object.
|
2006-05-06 14:44:32 +06:00
|
|
|
* \note Use method <VAR>GEOM_IShapesOperations.GetSubShapeIndex()</VAR> to get an ID by the sub shape
|
2004-12-01 15:39:14 +05:00
|
|
|
*/
|
|
|
|
|
void AddObject (in GEOM_Object theGroup, in long theSubShapeId);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Removes a sub object with ID \a theSubShapeId from the group
|
2005-02-04 11:55:40 +05:00
|
|
|
* \param theGroup is a GEOM group from which the sub shape is removed.
|
2004-12-01 15:39:14 +05:00
|
|
|
* \param theSubShapeId is a sub shape ID in the main object.
|
2006-05-06 14:44:32 +06:00
|
|
|
* \note Use method <VAR>GEOM_IShapesOperations.GetSubShapeIndex()</VAR> to get an ID by the sub shape
|
2004-12-01 15:39:14 +05:00
|
|
|
*/
|
|
|
|
|
void RemoveObject (in GEOM_Object theGroup, in long theSubShapeId);
|
|
|
|
|
|
2005-02-04 11:55:40 +05:00
|
|
|
/*!
|
|
|
|
|
* Adds to the group all the given shapes. No errors, if some shapes are alredy included.
|
|
|
|
|
* \param theGroup is a GEOM group to which the new sub shapes are added.
|
|
|
|
|
* \param theSubShapes is a list of sub shapes to be added.
|
|
|
|
|
*/
|
|
|
|
|
void UnionList (in GEOM_Object theGroup, in ListOfGO theSubShapes);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Removes from the group all the given shapes. No errors, if some shapes are not included.
|
|
|
|
|
* \param theGroup is a GEOM group from which the sub-shapes are removed.
|
|
|
|
|
* \param theSubShapes is a list of sub-shapes to be removed.
|
|
|
|
|
*/
|
|
|
|
|
void DifferenceList (in GEOM_Object theGroup, in ListOfGO theSubShapes);
|
|
|
|
|
|
2005-03-23 12:27:20 +05:00
|
|
|
/*!
|
|
|
|
|
* Adds to the group all the given shapes. No errors, if some shapes are alredy included.
|
|
|
|
|
* \param theGroup is a GEOM group to which the new sub shapes are added.
|
|
|
|
|
* \param theSubShapes is a list of IDs of sub shapes to be added.
|
|
|
|
|
*/
|
|
|
|
|
void UnionIDs (in GEOM_Object theGroup, in ListOfLong theSubShapes);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Removes from the group all the given shapes. No errors, if some shapes are not included.
|
|
|
|
|
* \param theGroup is a GEOM group from which the sub-shapes are removed.
|
|
|
|
|
* \param theSubShapes is a list of IDs of sub-shapes to be removed.
|
|
|
|
|
*/
|
|
|
|
|
void DifferenceIDs (in GEOM_Object theGroup, in ListOfLong theSubShapes);
|
|
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Returns a type of sub objects stored in the group
|
|
|
|
|
* \param theGroup is a GEOM group which type is returned.
|
|
|
|
|
*/
|
|
|
|
|
long GetType (in GEOM_Object theGroup);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Returns a main shape associated with the group
|
|
|
|
|
* \param theGroup is a GEOM group for which a main shape object is requested
|
|
|
|
|
* \return a GEOM object which is a main shape for theGroup
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetMainShape (in GEOM_Object theGroup);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Returns a list of sub objects ID stored in the group
|
|
|
|
|
* \param theGroup is a GEOM group for which a list of IDs is requested
|
|
|
|
|
*/
|
|
|
|
|
ListOfLong GetObjects (in GEOM_Object theGroup);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2010-05-14 21:15:28 +06:00
|
|
|
/*!
|
|
|
|
|
* GEOM_IAdvancedOperations: Interface for advanced modeling functions.
|
|
|
|
|
*/
|
|
|
|
|
interface GEOM_IAdvancedOperations : GEOM_IOperations
|
|
|
|
|
{
|
|
|
|
|
/*!
|
|
|
|
|
* Create a T-shape object with specified caracteristics for the main and
|
|
|
|
|
* the incident pipes (radius, width, half-length).
|
|
|
|
|
* Center of the shape is (0,0,0). The main plane of the T-shape is XOY.
|
|
|
|
|
* \param theR1 Internal radius of main pipe
|
|
|
|
|
* \param theW1 Width of main pipe
|
|
|
|
|
* \param theL1 Half-length of main pipe
|
|
|
|
|
* \param theR2 Internal radius of incident pipe (R2 < R1)
|
|
|
|
|
* \param theW2 Width of incident pipe (R2+W2 < R1+W1)
|
|
|
|
|
* \param theL2 Half-length of incident pipe
|
|
|
|
|
* \param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=true)
|
|
|
|
|
* \return List of GEOM_Objects, containing the created shape and propagation groups.
|
|
|
|
|
*/
|
2010-11-25 17:31:41 +05:00
|
|
|
ListOfGO MakePipeTShape (in double theR1, in double theW1, in double theL1,
|
2011-02-28 19:44:44 +05:00
|
|
|
in double theR2, in double theW2, in double theL2,
|
|
|
|
|
in boolean theHexMesh);
|
2010-05-14 21:15:28 +06:00
|
|
|
/*!
|
|
|
|
|
* Create a T-shape object with specified caracteristics for the main and
|
|
|
|
|
* the incident pipes (radius, width, half-length).
|
|
|
|
|
* The extremities of the main pipe are located on junctions points P1 and P2.
|
|
|
|
|
* The extremity of the incident pipe is located on junction point P3.
|
|
|
|
|
* \param theR1 Internal radius of main pipe
|
|
|
|
|
* \param theW1 Width of main pipe
|
|
|
|
|
* \param theL1 Half-length of main pipe
|
|
|
|
|
* \param theR2 Internal radius of incident pipe (R2 < R1)
|
|
|
|
|
* \param theW2 Width of incident pipe (R2+W2 < R1+W1)
|
|
|
|
|
* \param theL2 Half-length of incident pipe
|
|
|
|
|
* \param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=true)
|
|
|
|
|
* \param theP1 1st junction point of main pipe
|
|
|
|
|
* \param theP2 2nd junction point of main pipe
|
|
|
|
|
* \param theP3 Junction point of incident pipe
|
|
|
|
|
* \return List of GEOM_Objects, containing the created shape and propagation groups.
|
|
|
|
|
*/
|
2010-11-25 17:31:41 +05:00
|
|
|
ListOfGO MakePipeTShapeWithPosition (in double theR1, in double theW1, in double theL1,
|
2011-02-28 19:44:44 +05:00
|
|
|
in double theR2, in double theW2, in double theL2,
|
|
|
|
|
in boolean theHexMesh,
|
|
|
|
|
in GEOM_Object theP1, in GEOM_Object theP2, in GEOM_Object theP3);
|
2010-05-14 21:15:28 +06:00
|
|
|
/*!
|
|
|
|
|
* Create a T-shape object with specified caracteristics for the main and
|
|
|
|
|
* the incident pipes (radius, width, half-length). A chamfer is created
|
|
|
|
|
* on the junction of the pipes.
|
|
|
|
|
* Center of the shape is (0,0,0). The main plane of the T-shape is XOY.
|
|
|
|
|
* \param theR1 Internal radius of main pipe
|
|
|
|
|
* \param theW1 Width of main pipe
|
|
|
|
|
* \param theL1 Half-length of main pipe
|
|
|
|
|
* \param theR2 Internal radius of incident pipe (R2 < R1)
|
|
|
|
|
* \param theW2 Width of incident pipe (R2+W2 < R1+W1)
|
|
|
|
|
* \param theL2 Half-length of incident pipe
|
|
|
|
|
* \param theH Height of the chamfer.
|
|
|
|
|
* \param theW Width of the chamfer.
|
|
|
|
|
* \param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=true)
|
|
|
|
|
* \return List of GEOM_Objects, containing the created shape and propagation groups.
|
|
|
|
|
*/
|
|
|
|
|
ListOfGO MakePipeTShapeChamfer (in double theR1, in double theW1, in double theL1,
|
2010-11-25 17:31:41 +05:00
|
|
|
in double theR2, in double theW2, in double theL2,
|
|
|
|
|
in double theH, in double theW, in boolean theHexMesh);
|
2010-05-14 21:15:28 +06:00
|
|
|
/*!
|
|
|
|
|
* Create a T-shape object with specified caracteristics for the main and
|
|
|
|
|
* the incident pipes (radius, width, half-length). A chamfer is created
|
|
|
|
|
* on the junction of the pipes.
|
|
|
|
|
* The extremities of the main pipe are located on junctions points P1 and P2.
|
|
|
|
|
* The extremity of the incident pipe is located on junction point P3.
|
|
|
|
|
* \param theR1 Internal radius of main pipe
|
|
|
|
|
* \param theW1 Width of main pipe
|
|
|
|
|
* \param theL1 Half-length of main pipe
|
|
|
|
|
* \param theR2 Internal radius of incident pipe (R2 < R1)
|
|
|
|
|
* \param theW2 Width of incident pipe (R2+W2 < R1+W1)
|
|
|
|
|
* \param theL2 Half-length of incident pipe
|
|
|
|
|
* \param theH Height of the chamfer.
|
|
|
|
|
* \param theW Width of the chamfer.
|
|
|
|
|
* \param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=true)
|
|
|
|
|
* \param theP1 1st junction point of main pipe
|
|
|
|
|
* \param theP2 2nd junction point of main pipe
|
|
|
|
|
* \param theP3 Junction point of incident pipe
|
|
|
|
|
* \return List of GEOM_Objects, containing the created shape and propagation groups.
|
|
|
|
|
*/
|
2010-11-25 17:31:41 +05:00
|
|
|
ListOfGO MakePipeTShapeChamferWithPosition (in double theR1, in double theW1, in double theL1,
|
2011-02-28 19:44:44 +05:00
|
|
|
in double theR2, in double theW2, in double theL2,
|
|
|
|
|
in double theH, in double theW, in boolean theHexMesh,
|
|
|
|
|
in GEOM_Object theP1, in GEOM_Object theP2, in GEOM_Object theP3);
|
2010-05-14 21:15:28 +06:00
|
|
|
/*!
|
|
|
|
|
* Create a T-shape object with specified caracteristics for the main and
|
|
|
|
|
* the incident pipes (radius, width, half-length). A fillet is created
|
|
|
|
|
* on the junction of the pipes.
|
|
|
|
|
* Center of the shape is (0,0,0). The main plane of the T-shape is XOY.
|
|
|
|
|
* \param theR1 Internal radius of main pipe
|
|
|
|
|
* \param theW1 Width of main pipe
|
|
|
|
|
* \param theL1 Half-length of main pipe
|
|
|
|
|
* \param theR2 Internal radius of incident pipe (R2 < R1)
|
|
|
|
|
* \param theW2 Width of incident pipe (R2+W2 < R1+W1)
|
|
|
|
|
* \param theL2 Half-length of incident pipe
|
|
|
|
|
* \param theRF Radius of curvature of fillet.
|
|
|
|
|
* \param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=true)
|
|
|
|
|
* \return List of GEOM_Objects, containing the created shape and propagation groups.
|
|
|
|
|
*/
|
2010-11-25 17:31:41 +05:00
|
|
|
ListOfGO MakePipeTShapeFillet (in double theR1, in double theW1, in double theL1,
|
2011-02-28 19:44:44 +05:00
|
|
|
in double theR2, in double theW2, in double theL2,
|
|
|
|
|
in double theRF, in boolean theHexMesh);
|
2010-05-14 21:15:28 +06:00
|
|
|
/*!
|
|
|
|
|
* Create a T-shape object with specified caracteristics for the main and
|
|
|
|
|
* the incident pipes (radius, width, half-length). A fillet is created
|
|
|
|
|
* on the junction of the pipes.
|
|
|
|
|
* The extremities of the main pipe are located on junctions points P1 and P2.
|
|
|
|
|
* The extremity of the incident pipe is located on junction point P3.
|
|
|
|
|
* \param theR1 Internal radius of main pipe
|
|
|
|
|
* \param theW1 Width of main pipe
|
|
|
|
|
* \param theL1 Half-length of main pipe
|
|
|
|
|
* \param theR2 Internal radius of incident pipe (R2 < R1)
|
|
|
|
|
* \param theW2 Width of incident pipe (R2+W2 < R1+W1)
|
|
|
|
|
* \param theL2 Half-length of incident pipe
|
|
|
|
|
* \param theRF Radius of curvature of fillet.
|
|
|
|
|
* \param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=true)
|
|
|
|
|
* \param theP1 1st junction point of main pipe
|
|
|
|
|
* \param theP2 2nd junction point of main pipe
|
|
|
|
|
* \param theP3 Junction point of incident pipe
|
|
|
|
|
* \return List of GEOM_Objects, containing the created shape and propagation groups.
|
|
|
|
|
*/
|
2010-11-25 17:31:41 +05:00
|
|
|
ListOfGO MakePipeTShapeFilletWithPosition (in double theR1, in double theW1, in double theL1,
|
2011-02-28 19:44:44 +05:00
|
|
|
in double theR2, in double theW2, in double theL2,
|
|
|
|
|
in double theRF, in boolean theHexMesh,
|
|
|
|
|
in GEOM_Object theP1, in GEOM_Object theP2, in GEOM_Object theP3);
|
2010-05-14 21:15:28 +06:00
|
|
|
/*@@ insert new functions before this line @@ do not remove this line @@*/
|
|
|
|
|
};
|
2010-11-25 17:31:41 +05:00
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* GEOM_Gen: Interface to access other GEOM interfaces.
|
|
|
|
|
* Also contains some methods to access and manage GEOM objects.
|
|
|
|
|
*/
|
2011-02-28 19:44:44 +05:00
|
|
|
interface GEOM_Gen : Engines::EngineComponent,SALOMEDS::Driver
|
2003-05-12 20:51:31 +06:00
|
|
|
{
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Undo/Redo Management
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
void Undo (in long theStudyID);
|
|
|
|
|
|
|
|
|
|
void Redo (in long theStudyID);
|
|
|
|
|
|
|
|
|
|
/*!
|
2009-02-13 17:16:39 +05:00
|
|
|
* Publishing management
|
2004-12-01 15:39:14 +05:00
|
|
|
* Adds in theStudy a object theObject under with a name theName,
|
|
|
|
|
* if theFather is not NULL the object is placed under thFather's SObject.
|
|
|
|
|
* Returns a SObject where theObject is placed
|
|
|
|
|
*/
|
|
|
|
|
SALOMEDS::SObject AddInStudy (in SALOMEDS::Study theStudy,
|
2010-11-25 17:31:41 +05:00
|
|
|
in GEOM_Object theObject,
|
|
|
|
|
in string theName,
|
|
|
|
|
in GEOM_Object theFather);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
2009-02-13 17:16:39 +05:00
|
|
|
/*!
|
|
|
|
|
* Publish sub-shapes, standing for arguments and sub-shapes of arguments
|
|
|
|
|
* To be used from python scripts out of geompy.addToStudy (non-default usage)
|
|
|
|
|
* \param theStudy the study, in which theObject is published already,
|
|
|
|
|
* and in which the arguments will be published
|
|
|
|
|
* \param theObject published GEOM object, arguments of which will be published
|
|
|
|
|
* \param theArgs list of GEOM_Object, operation arguments to be published.
|
|
|
|
|
* If this list is empty, all operation arguments will be published
|
|
|
|
|
* \param theFindMethod method to search subshapes, corresponding to arguments and
|
|
|
|
|
* their subshapes. Value from enumeration GEOM::find_shape_method.
|
|
|
|
|
* \param theInheritFirstArg set properties of the first argument for \a theObject.
|
|
|
|
|
* Do not publish subshapes in place of arguments, but only
|
|
|
|
|
* in place of subshapes of the first argument,
|
|
|
|
|
* because the whole shape corresponds to the first argument.
|
|
|
|
|
* Mainly to be used after transformations, but it also can be
|
|
|
|
|
* usefull after partition with one object shape, and some other
|
|
|
|
|
* operations, where only the first argument has to be considered.
|
|
|
|
|
* If theObject has only one argument shape, this flag is automatically
|
|
|
|
|
* considered as True, not regarding really passed value.
|
2010-05-14 21:15:28 +06:00
|
|
|
* \param theAddPrefix add prefix "from_" to names of restored sub-shapes,
|
|
|
|
|
* and prefix "from_subshapes_of_" to names of partially restored subshapes.
|
2009-07-24 19:38:16 +06:00
|
|
|
* \return list of published sub-shapes
|
2009-02-13 17:16:39 +05:00
|
|
|
*/
|
2009-06-10 17:36:36 +06:00
|
|
|
ListOfGO RestoreSubShapesO (in SALOMEDS::Study theStudy,
|
2011-02-28 19:44:44 +05:00
|
|
|
in GEOM_Object theObject,
|
2010-11-25 17:31:41 +05:00
|
|
|
in ListOfGO theArgs,
|
|
|
|
|
in find_shape_method theFindMethod,
|
|
|
|
|
in boolean theInheritFirstArg,
|
2010-05-14 21:15:28 +06:00
|
|
|
in boolean theAddPrefix);
|
2009-02-13 17:16:39 +05:00
|
|
|
|
2010-11-25 17:31:41 +05:00
|
|
|
/*!
|
|
|
|
|
* Publish sub-shapes, standing for arguments and sub-shapes of arguments
|
|
|
|
|
* To be used from python scripts out of geompy.addToStudy (non-default usage)
|
|
|
|
|
* \param theStudy the study, in which theObject is published already,
|
|
|
|
|
* and in which the arguments will be published
|
|
|
|
|
* \param theObject published GEOM object, arguments of which will be published
|
|
|
|
|
* \param theArgs list of GEOM_Object, operation arguments to be published.
|
|
|
|
|
* If this list is empty, all operation arguments will be published
|
|
|
|
|
* \param theFindMethod method to search subshapes, corresponding to arguments and
|
|
|
|
|
* their subshapes. Value from enumeration GEOM::find_shape_method.
|
|
|
|
|
* \param theInheritFirstArg set properties of the first argument for \a theObject.
|
|
|
|
|
* Do not publish subshapes in place of arguments, but only
|
|
|
|
|
* in place of subshapes of the first argument,
|
|
|
|
|
* because the whole shape corresponds to the first argument.
|
|
|
|
|
* Mainly to be used after transformations, but it also can be
|
|
|
|
|
* usefull after partition with one object shape, and some other
|
|
|
|
|
* operations, where only the first argument has to be considered.
|
|
|
|
|
* If theObject has only one argument shape, this flag is automatically
|
|
|
|
|
* considered as True, not regarding really passed value.
|
|
|
|
|
* \param theAddPrefix add prefix "from_" to names of restored sub-shapes,
|
|
|
|
|
* and prefix "from_subshapes_of_" to names of partially restored subshapes.
|
|
|
|
|
* \return list of published sub-shapes
|
|
|
|
|
*/
|
|
|
|
|
ListOfGO RestoreGivenSubShapesO (in SALOMEDS::Study theStudy,
|
|
|
|
|
in GEOM_Object theObject,
|
|
|
|
|
in ListOfGO theArgs,
|
|
|
|
|
in find_shape_method theFindMethod,
|
|
|
|
|
in boolean theInheritFirstArg,
|
|
|
|
|
in boolean theAddPrefix);
|
|
|
|
|
|
2009-02-13 17:16:39 +05:00
|
|
|
/*!
|
|
|
|
|
* Publish sub-shapes, standing for arguments and sub-shapes of arguments
|
|
|
|
|
* To be used from GUI and from geompy.addToStudy.
|
|
|
|
|
* Work like the above method, but accepts study object theSObject instead of GEOM_Object.
|
|
|
|
|
* \param theSObject study object, referencing GEOM object, arguments of which will be published
|
|
|
|
|
*/
|
2009-06-10 17:36:36 +06:00
|
|
|
ListOfGO RestoreSubShapesSO (in SALOMEDS::Study theStudy,
|
2010-11-25 17:31:41 +05:00
|
|
|
in SALOMEDS::SObject theSObject,
|
|
|
|
|
in ListOfGO theArgs,
|
|
|
|
|
in find_shape_method theFindMethod,
|
|
|
|
|
in boolean theInheritFirstArg,
|
2010-05-14 21:15:28 +06:00
|
|
|
in boolean theAddPrefix);
|
2009-02-13 17:16:39 +05:00
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Methods to access interfaces for objects creation and transformation
|
|
|
|
|
*/
|
|
|
|
|
GEOM_IBasicOperations GetIBasicOperations (in long theStudyID) raises (SALOME::SALOME_Exception);
|
|
|
|
|
GEOM_ITransformOperations GetITransformOperations(in long theStudyID) raises (SALOME::SALOME_Exception);
|
|
|
|
|
GEOM_I3DPrimOperations GetI3DPrimOperations (in long theStudyID) raises (SALOME::SALOME_Exception);
|
|
|
|
|
GEOM_IShapesOperations GetIShapesOperations (in long theStudyID) raises (SALOME::SALOME_Exception);
|
|
|
|
|
GEOM_IBooleanOperations GetIBooleanOperations (in long theStudyID) raises (SALOME::SALOME_Exception);
|
|
|
|
|
GEOM_ICurvesOperations GetICurvesOperations (in long theStudyID) raises (SALOME::SALOME_Exception);
|
|
|
|
|
GEOM_ILocalOperations GetILocalOperations (in long theStudyID) raises (SALOME::SALOME_Exception);
|
|
|
|
|
GEOM_IHealingOperations GetIHealingOperations (in long theStudyID) raises (SALOME::SALOME_Exception);
|
|
|
|
|
GEOM_IInsertOperations GetIInsertOperations (in long theStudyID) raises (SALOME::SALOME_Exception);
|
|
|
|
|
GEOM_IMeasureOperations GetIMeasureOperations (in long theStudyID) raises (SALOME::SALOME_Exception);
|
|
|
|
|
GEOM_IBlocksOperations GetIBlocksOperations (in long theStudyID) raises (SALOME::SALOME_Exception);
|
|
|
|
|
GEOM_IGroupOperations GetIGroupOperations (in long theStudyID) raises (SALOME::SALOME_Exception);
|
2010-05-14 21:15:28 +06:00
|
|
|
GEOM_IAdvancedOperations GetIAdvancedOperations (in long theStudyID) raises (SALOME::SALOME_Exception);
|
2004-12-01 15:39:14 +05:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Objects Management
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Removes the object from the GEOM component
|
|
|
|
|
* \param theObject is a GEOM object to be removed
|
|
|
|
|
*/
|
|
|
|
|
void RemoveObject (in GEOM_Object theObject);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Returns an object defined by the study and its entry in the GEOM component
|
|
|
|
|
* \param theStudyID is a SALOMEDS Study ID
|
|
|
|
|
* \param theEntry is an entry of the requested GEOM object in the GEOM component
|
|
|
|
|
* \note if the object has not previously been created a NULL GEOM object is returned
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetObject (in long theStudyID, in string theEntry);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Add a sub shape defined by indices in \a theIndices
|
|
|
|
|
* (contains unique IDs of sub shapes inside theMainShape)
|
|
|
|
|
* \note The sub shape GEOM_Objects can has ONLY ONE function.
|
|
|
|
|
* Don't try to apply modification operations on them.
|
|
|
|
|
* \note Internal method
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object AddSubShape (in GEOM_Object theMainShape, in ListOfLong theIndices);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* GEOM object's IOR Management
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Returns a GEOM Object defined by its IOR
|
|
|
|
|
* \param theIOR a string containg an IOR of the requested GEOM object
|
|
|
|
|
*/
|
|
|
|
|
GEOM_Object GetIORFromString (in string theIOR);
|
2003-05-12 20:51:31 +06:00
|
|
|
|
2004-12-01 15:39:14 +05:00
|
|
|
/*!
|
|
|
|
|
* Returns a string which contains an IOR of the GEOM object
|
|
|
|
|
* \param theObject is a GEOM object which IOR is requested
|
|
|
|
|
*/
|
|
|
|
|
string GetStringFromIOR (in GEOM_Object theObject);
|
2005-06-02 13:17:09 +06:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Returns a name with which a GEOM object was dumped into python script
|
|
|
|
|
* \param theStudyEntry is an entry of the GEOM object in the study
|
|
|
|
|
*/
|
|
|
|
|
string GetDumpName (in string theStudyEntry);
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Returns all names with which a GEOM objects was dumped
|
|
|
|
|
* into python script to avoid the same names in SMESH script
|
|
|
|
|
*/
|
|
|
|
|
string_array GetAllDumpNames();
|
2009-06-03 13:17:42 +06:00
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Publishes the named subshapes of given object in the study.
|
|
|
|
|
* \param theStudy The study in which the object is published
|
|
|
|
|
* \param theObject The object which named subshapes are published
|
|
|
|
|
*/
|
|
|
|
|
ListOfGO PublishNamedShapesInStudy(in SALOMEDS::Study theStudy,
|
2010-11-25 17:31:41 +05:00
|
|
|
//in SObject theSObject,
|
|
|
|
|
in Object theObject);
|
2003-05-12 20:51:31 +06:00
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#endif
|
