446 lines
28 KiB
C++
446 lines
28 KiB
C++
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright 2016 Autodesk, Inc. All rights reserved.
|
|
//
|
|
// Use of this software is subject to the terms of the Autodesk license
|
|
// agreement provided at the time of installation or download, or which
|
|
// otherwise accompanies this software.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
#pragma once
|
|
#include "../../Core/Base.h"
|
|
#include "../FusionTypeDefs.h"
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
// THIS CLASS WILL BE VISIBLE TO AN API CLIENT.
|
|
// THIS HEADER FILE WILL BE GENERATED FROM NIDL.
|
|
#include "../../Core/OSMacros.h"
|
|
|
|
#ifdef FUSIONXINTERFACE_EXPORTS
|
|
# ifdef __COMPILING_ADSK_FUSION_TEMPORARYBREPMANAGER_CPP__
|
|
# define ADSK_FUSION_TEMPORARYBREPMANAGER_API XI_EXPORT
|
|
# else
|
|
# define ADSK_FUSION_TEMPORARYBREPMANAGER_API
|
|
# endif
|
|
#else
|
|
# define ADSK_FUSION_TEMPORARYBREPMANAGER_API XI_IMPORT
|
|
#endif
|
|
|
|
namespace adsk { namespace fusion {
|
|
class BRepBodies;
|
|
class BRepBody;
|
|
class BRepEdge;
|
|
class BRepFace;
|
|
class BRepWire;
|
|
}}
|
|
namespace adsk { namespace core {
|
|
class Curve3D;
|
|
class Matrix3D;
|
|
class OrientedBoundingBox3D;
|
|
class Plane;
|
|
class Point3D;
|
|
class Vector3D;
|
|
}}
|
|
|
|
namespace adsk { namespace fusion {
|
|
|
|
/// A utility object that provides functionality to create and manipulate B-Rep data outside
|
|
/// the context of a document. The provides direct access to the modeling core without the
|
|
/// overhead of parametrics, persistence, transactions, or graphics. It also provides a way
|
|
/// of directly defining and creating B-Rep data.
|
|
class TemporaryBRepManager : public core::Base {
|
|
public:
|
|
|
|
/// Gets the TempoaryBRepManager object. This object provides access to functionality to
|
|
/// create an manipulate temporary B-Rep data outside the context of a document.
|
|
/// Returns the TemporaryBRepManager object.
|
|
static core::Ptr<TemporaryBRepManager> get();
|
|
|
|
/// Creates a temporary copy of the input BRepBody, BRepFace, or BRepEdge object.
|
|
/// bRepEntity : The BRepBody, BRepFace, BRepLoop, or BRepEdge to create a copy of. This can be a parametric
|
|
/// B-Rep entity or a temporary B-Rep entity.
|
|
/// Returns a BRepBody that contains the result. If a BRepBody is input the copy is
|
|
/// of the entire body. If a BRepFace is input, then the result is a BRepBody that
|
|
/// contains a single face. If a BRepLoop is input then the result is a BRepBody that
|
|
/// contains a wire where each edge in the loop will have a corresponding edge in the wire.
|
|
/// If a BRepEdge is input then the result is a BRepBody that contains a wire that contains
|
|
/// the single edge.
|
|
core::Ptr<BRepBody> copy(const core::Ptr<core::Base>& bRepEntity);
|
|
|
|
/// Calculates the intersection between the input body and plane and creates a
|
|
/// wire body that represents the intersection curves.
|
|
/// body : The BRepBody to intersection.
|
|
/// plane : The geometry Plane to intersect with the body.
|
|
/// Returns a BRepBody that contains a wire body that represents the intersection.
|
|
core::Ptr<BRepBody> planeIntersection(const core::Ptr<BRepBody>& body, const core::Ptr<core::Plane>& plane);
|
|
|
|
/// Creates a new body by creating a ruled surface between the two input wire bodies.
|
|
/// sectionOne : BRepWire that defines the shape of the first section.
|
|
/// sectionTwo : BRepWire that defines the shape of the second section.
|
|
/// Returns the created ruled surface as a BRepBody object.
|
|
core::Ptr<BRepBody> createRuledSurface(const core::Ptr<BRepWire>& sectionOne, const core::Ptr<BRepWire>& sectionTwo);
|
|
|
|
/// Calculates the silhouette curve geometry for a given face as viewed from a given direction.
|
|
/// face : Input BRepFace object to calculate the silhouette curve for.
|
|
/// viewDirection : Input Vector3D object that defines the view direction to calculate the silhouette curve relative to.
|
|
/// The silhouette curve(s) will lie along the path where the face normal is perpendicular to the view direction.
|
|
/// returnCoincidentSilhouettes : Input Boolean that specifies if silhouette curves that are coincident to the edges of the face should be
|
|
/// returned or not. If true, these curves will be returned.
|
|
/// Returns a SurfaceBody object that will contain one or more BRepWire objects that represent the silhouette curve(s).
|
|
/// This method can return null in the case where there is not a silhouette curve for the specified face.
|
|
core::Ptr<BRepBody> createSilhouetteCurves(const core::Ptr<BRepFace>& face, const core::Ptr<core::Vector3D>& viewDirection, bool returnCoincidentSilhouettes);
|
|
|
|
/// Deletes one or more faces from a temporary BRepBody. The body that will be modified is determined
|
|
/// by getting the parent body of the input faces.
|
|
/// faces : An array of BRepFace objects to delete. If more than one face is provided,
|
|
/// all of the faces must exist within the same body.
|
|
/// deleteSpecifiedFaces : This allows you to either delete the faces that were input or to keep those faces and delete all the
|
|
/// other faces in the body.
|
|
/// Returns true if the operation was successful.
|
|
bool deleteFaces(const std::vector<core::Ptr<BRepFace>>& faces, bool deleteSpecifiedFaces);
|
|
|
|
/// Performs the specified Boolean operation between the two input bodies. The input bodies need
|
|
/// not be solid but can be faces that are combined or trimmed.
|
|
/// targetBody : The target body that will be modified as a result of the Boolean operation.
|
|
/// toolBody : The tool body that will be used to operate on the target body.
|
|
/// booleanType : The type of Boolean operation to perform.
|
|
/// Returns true if the operation was successful. If successful, the target body is modified as a result of the
|
|
/// Boolean operation. Because of this the targetBody must always be a temporary BRepBody. The tool body is not
|
|
/// modified. This is analogous to a machining operation where you have the target that is being machined and
|
|
/// the tool that removes material.
|
|
bool booleanOperation(const core::Ptr<BRepBody>& targetBody, const core::Ptr<BRepBody>& toolBody, BooleanTypes booleanType);
|
|
|
|
/// Transforms the input body using the specified transformation matrix.
|
|
/// body : The BRepBody object to transform.
|
|
/// transform : The transformation matrix that defines the transform to apply to the body.
|
|
/// Returns true if the specified transform was successfully applied to the body.
|
|
bool transform(const core::Ptr<BRepBody>& body, const core::Ptr<core::Matrix3D>& transform);
|
|
|
|
/// Creates new BRepBody objects based on the contents of the specified file.
|
|
/// filename : The full path and name of the file to read in. This can be a SMT, SMB, SAT, or SAB file.
|
|
/// A BRepBodies collection object is returned which can contain multiple BRepBody objects.
|
|
/// null is returned in the case where it was unable to read the file.
|
|
core::Ptr<BRepBodies> createFromFile(const std::string& filename);
|
|
|
|
/// Exports the input bodies to the specified file.
|
|
/// bodies : An array of BRepBody objects that you want to export.
|
|
/// filename : The filename to write the BRepBody objects to. The type of file to create
|
|
/// is inferred from the extension of the file. The valid extensions are ".sat" and ".smt".
|
|
/// Returns true if the export was successful.
|
|
bool exportToFile(const std::vector<core::Ptr<BRepBody>>& bodies, const std::string& filename);
|
|
|
|
/// Creates a new temporary solid box BRepBody object.
|
|
/// box : The OrientedBoundingBox3D object that defines the position, orientation, and
|
|
/// size of the box to crate.
|
|
/// Returns the newly created temporary BRepBody object or null in the case of failure.
|
|
core::Ptr<BRepBody> createBox(const core::Ptr<core::OrientedBoundingBox3D>& box);
|
|
|
|
/// Creates a temporary solid cylinder or cone BRepBody object.
|
|
/// pointOne : A point at one end of the cylinder or cone.
|
|
/// pointOneRadius : The radius of the cylinder or cone at the point one end, in centimeters.
|
|
/// pointTwo : A point at the opposite end of the cylinder or cone.
|
|
/// pointTwoRadius : The radius of the cylinder or cone at the point two end, in centimeters.
|
|
/// For a cylinder the pointTwoRadius should be equal to the pointOneRadius.
|
|
/// Returns the newly created temporary BRepBody object or null in the case of failure.
|
|
core::Ptr<BRepBody> createCylinderOrCone(const core::Ptr<core::Point3D>& pointOne, double pointOneRadius, const core::Ptr<core::Point3D>& pointTwo, double pointTwoRadius);
|
|
|
|
/// Creates a temporary elliptical solid cylinder or cone BrepBody object.
|
|
/// pointOne : A point at one end of the cylinder or cone.
|
|
/// pointOneMajorRadius : The major radius of the cylinder or cone at the point one end, in centimeters.
|
|
/// pointOneMinorRadius : The minor radius of the cylinder or cone at the point one end, in centimeters.
|
|
/// pointTwo : A point at the opposite end of the cone.
|
|
/// pointTwoMajorRadius : The major radius of the cylinder or cone at the point two end, in centimeters. The
|
|
/// minor radius is automatically determined using the point one ratio of the minor and major
|
|
/// radii.
|
|
/// majorAxisDirection : A Vector3D object that defines the direction of the major axis.
|
|
/// Returns the newly created temporary BRepBody object or null in the case of failure.
|
|
core::Ptr<BRepBody> createEllipticalCylinderOrCone(const core::Ptr<core::Point3D>& pointOne, double pointOneMajorRadius, double pointOneMinorRadius, const core::Ptr<core::Point3D>& pointTwo, double pointTwoMajorRadius, const core::Ptr<core::Vector3D>& majorAxisDirection);
|
|
|
|
/// Creates a temporary spherical BRepBody object.
|
|
/// center : The center point of the sphere.
|
|
/// radius : The radius of the sphere in centimeters.
|
|
/// Returns the newly created temporary BRepBody object or null in the case of failure.
|
|
core::Ptr<BRepBody> createSphere(const core::Ptr<core::Point3D>& center, double radius);
|
|
|
|
/// Creates a temporary toroidal BRepBody object.
|
|
/// center : The center point of the torus.
|
|
/// axis : The axis of the torus.
|
|
/// majorRadius : The radius, in centimeters, of the major radius of the torus. If the torus was created
|
|
/// by sweeping a circle around another circle this would be the radius of the path circle.
|
|
/// minorRadius : The radius, in centimeters, of the minor radius of the torus. If the torus was created
|
|
/// by sweeping a circle around another circle this would be the radius of the profile circle.
|
|
/// Returns the newly created temporary BRepBody object or null in the case of failure.
|
|
core::Ptr<BRepBody> createTorus(const core::Ptr<core::Point3D>& center, const core::Ptr<core::Vector3D>& axis, double majorRadius, double minorRadius);
|
|
|
|
/// Creates a body from multiple wires that all lie within the same plane. Multiple wires are
|
|
/// used when creating a plane with interior holes. One wire defines the outer shape and the
|
|
/// other wires define the interior loops of the created face.
|
|
/// wireBodies : An array of bodies that contain planar wires. Each wire must be closed, they should not overlap,
|
|
/// and they should all lie on the same plane.
|
|
/// Returns a BRepBody containing the created BRepFace object or null in the case of failure.
|
|
core::Ptr<BRepBody> createFaceFromPlanarWires(const std::vector<core::Ptr<BRepBody>>& wireBodies);
|
|
|
|
/// <p>Method that finds regions of faces on two bodies which overlap and creates new bodies where the faces
|
|
/// are split at the edges of the overlaps. This does not modify the original bodies but creates new
|
|
/// temporary bodies that contain the imprints.</p>
|
|
/// <p>The picture below shows an example of imprinting. The picture on the left shows the initial two bodies
|
|
/// that are positioned so there are coincident faces. The picture on the right shows the two bodies individually
|
|
/// so you can see the result of the imprint and how the coincident faces were split. </p>
|
|
/// <br/><br/><center><img src="../Images/ImprintBodies.png"></center><br/>
|
|
/// <p>The ability to imprint solids can be important to applications that need to mesh models. By creating edges
|
|
/// at the points where solids connect, it guarantees that there will be mesh nodes along those boundaries.</p>
|
|
/// bodyOne : Input BRepBody that will participate in the imprint operation. This body can be either a parametric
|
|
/// or temporary body.
|
|
/// bodyTwo : Input BRepBody that will participate in the imprint operation. This body can be either a parametric
|
|
/// or temporary body.
|
|
/// imprintCoincidentEdges : <p>Input Boolean that indicates if overlapping edges should be included in the result. The picture below
|
|
/// shows an example of when this argument will make a difference. The two bodies have overlapping faces
|
|
/// and there is also an overlapping edge. If this argument is true, then the edge shown in red below
|
|
/// will be included in the output as an overlapping edge. If False it will not be included and only
|
|
/// the edges of the overlapping faces will be in the overlapping faces collections.</p>
|
|
/// <br/><br/><center><img src="../Images/ImprintOverlappingEdges.png"></center>
|
|
/// resultBodyOne : Output temporary BRepBody that contains the imprinted body that corresponds to the body provided through the bodyOne argument.
|
|
/// resultBodyTwo : Output temporary BRepBody that contains the imprinted body that corresponds to the body provided through the bodyTwo argument.
|
|
/// bodyOneOverlappingFaces : Output array of BRepFace objects that represent the overlapping faces that are part of resultBodyOne. Faces at the same index within the
|
|
/// collection returned here and that returned by the bodyTwoOverlappingFaces are overlapping.
|
|
/// bodyTwoOverlappingFaces : Output array of BRepFace objects that represent the overlapping faces that are part of resultBodyTwo. Faces at the same index within the
|
|
/// collection returned here and that returned by the bodyOneOverlappingFaces are overlapping.
|
|
/// bodyOneOverlappingEdges : Output array of BRepEdge objects that represent the overlapping edges that are part of resultBodyOne. Edges at the same index within the
|
|
/// collection returned here and that returned by the bodyTwoOverlappingEdges are overlapping.
|
|
/// bodyTwoOverlappingEdges : Output array of BRepEdge objects that represent the overlapping edges that are part of resultBodyTwo. Edges at the same index within the
|
|
/// collection returned here and that returned by the bodyOneOverlappingEdges are overlapping.
|
|
/// tolerance : Optional Input double that specifies the tolerance, in centimeters, to use when comparing the bodies. If not specified, or a value of zero
|
|
/// is specified, the internal modeling tolerance will be used.
|
|
/// Returns true if the imprint calculation was successful.
|
|
bool imprintOverlapBodies(const core::Ptr<BRepBody>& bodyOne, const core::Ptr<BRepBody>& bodyTwo, bool imprintCoincidentEdges, core::Ptr<BRepBody>& resultBodyOne, core::Ptr<BRepBody>& resultBodyTwo, std::vector<core::Ptr<BRepFace>>& bodyOneOverlappingFaces, std::vector<core::Ptr<BRepFace>>& bodyTwoOverlappingFaces, std::vector<core::Ptr<BRepEdge>>& bodyOneOverlappingEdges, std::vector<core::Ptr<BRepEdge>>& bodyTwoOverlappingEdges, double tolerance = 0);
|
|
|
|
/// Give an array of curve geometry objects, this method creates a new wire body.
|
|
/// curves : An array containing the input Curve3D objects. These can be Arc3D, Circle3D, Ellipse3D, EllipticalArc3D or Line3D objects.
|
|
/// edgeMap : An array of edges in the returned body. The order that the edges are in this collection is the
|
|
/// same order as the original corresponding Curve3D object is in the input curves array. This allows you to
|
|
/// map between the original input curve and created edge.
|
|
/// allowSelfIntersections : Specifies if you want to allow self-intersection in the input curves or not.
|
|
/// Returns the B-Rep body containing the created wire or null in the case of failure.
|
|
core::Ptr<BRepBody> createWireFromCurves(const std::vector<core::Ptr<core::Curve3D>>& curves, std::vector<core::Ptr<BRepEdge>>& edgeMap, bool allowSelfIntersections = false);
|
|
|
|
/// Creates a B-Rep body that contains a wire with a single edge that represents a helical curve.
|
|
/// axisPoint : A Point3D object that defines a point along the axis of the helix.
|
|
/// axisVector : A Vector3D object that defines the direction of the axis of the helix.
|
|
/// startPoint : A Point3D that defines the start point of the helix. This is a point on the helix and defines the starting
|
|
/// point of the helix. The distance of this point to the axis defines the starting radius of the helix.
|
|
/// pitch : The pitch of the helix, or the distance between each of the turns, in centimeters.
|
|
/// turns : The number of turns of the helix.
|
|
/// taperAngle : The taper angle of the helix in radians.
|
|
///
|
|
core::Ptr<BRepBody> createHelixWire(const core::Ptr<core::Point3D>& axisPoint, const core::Ptr<core::Vector3D>& axisVector, const core::Ptr<core::Point3D>& startPoint, double pitch, double turns, double taperAngle);
|
|
|
|
ADSK_FUSION_TEMPORARYBREPMANAGER_API static const char* classType();
|
|
ADSK_FUSION_TEMPORARYBREPMANAGER_API const char* objectType() const override;
|
|
ADSK_FUSION_TEMPORARYBREPMANAGER_API void* queryInterface(const char* id) const override;
|
|
ADSK_FUSION_TEMPORARYBREPMANAGER_API static const char* interfaceId() { return classType(); }
|
|
|
|
private:
|
|
|
|
// Raw interface
|
|
ADSK_FUSION_TEMPORARYBREPMANAGER_API static TemporaryBRepManager* get_raw();
|
|
virtual BRepBody* copy_raw(core::Base* bRepEntity) = 0;
|
|
virtual BRepBody* planeIntersection_raw(BRepBody* body, core::Plane* plane) = 0;
|
|
virtual BRepBody* createRuledSurface_raw(BRepWire* sectionOne, BRepWire* sectionTwo) = 0;
|
|
virtual BRepBody* createSilhouetteCurves_raw(BRepFace* face, core::Vector3D* viewDirection, bool returnCoincidentSilhouettes) = 0;
|
|
virtual bool deleteFaces_raw(BRepFace** faces, size_t faces_size, bool deleteSpecifiedFaces) = 0;
|
|
virtual bool booleanOperation_raw(BRepBody* targetBody, BRepBody* toolBody, BooleanTypes booleanType) = 0;
|
|
virtual bool transform_raw(BRepBody* body, core::Matrix3D* transform) = 0;
|
|
virtual BRepBodies* createFromFile_raw(const char * filename) = 0;
|
|
virtual bool exportToFile_raw(BRepBody** bodies, size_t bodies_size, const char * filename) = 0;
|
|
virtual BRepBody* createBox_raw(core::OrientedBoundingBox3D* box) = 0;
|
|
virtual BRepBody* createCylinderOrCone_raw(core::Point3D* pointOne, double pointOneRadius, core::Point3D* pointTwo, double pointTwoRadius) = 0;
|
|
virtual BRepBody* createEllipticalCylinderOrCone_raw(core::Point3D* pointOne, double pointOneMajorRadius, double pointOneMinorRadius, core::Point3D* pointTwo, double pointTwoMajorRadius, core::Vector3D* majorAxisDirection) = 0;
|
|
virtual BRepBody* createSphere_raw(core::Point3D* center, double radius) = 0;
|
|
virtual BRepBody* createTorus_raw(core::Point3D* center, core::Vector3D* axis, double majorRadius, double minorRadius) = 0;
|
|
virtual BRepBody* createFaceFromPlanarWires_raw(BRepBody** wireBodies, size_t wireBodies_size) = 0;
|
|
virtual bool imprintOverlapBodies_raw(BRepBody* bodyOne, BRepBody* bodyTwo, bool imprintCoincidentEdges, BRepBody*& resultBodyOne, BRepBody*& resultBodyTwo, BRepFace**& bodyOneOverlappingFaces, size_t& bodyOneOverlappingFaces_size, BRepFace**& bodyTwoOverlappingFaces, size_t& bodyTwoOverlappingFaces_size, BRepEdge**& bodyOneOverlappingEdges, size_t& bodyOneOverlappingEdges_size, BRepEdge**& bodyTwoOverlappingEdges, size_t& bodyTwoOverlappingEdges_size, double tolerance) = 0;
|
|
virtual BRepBody* createWireFromCurves_raw(core::Curve3D** curves, size_t curves_size, BRepEdge**& edgeMap, size_t& edgeMap_size, bool allowSelfIntersections) = 0;
|
|
virtual BRepBody* createHelixWire_raw(core::Point3D* axisPoint, core::Vector3D* axisVector, core::Point3D* startPoint, double pitch, double turns, double taperAngle) = 0;
|
|
};
|
|
|
|
// Inline wrappers
|
|
|
|
inline core::Ptr<TemporaryBRepManager> TemporaryBRepManager::get()
|
|
{
|
|
core::Ptr<TemporaryBRepManager> res = get_raw();
|
|
return res;
|
|
}
|
|
|
|
inline core::Ptr<BRepBody> TemporaryBRepManager::copy(const core::Ptr<core::Base>& bRepEntity)
|
|
{
|
|
core::Ptr<BRepBody> res = copy_raw(bRepEntity.get());
|
|
return res;
|
|
}
|
|
|
|
inline core::Ptr<BRepBody> TemporaryBRepManager::planeIntersection(const core::Ptr<BRepBody>& body, const core::Ptr<core::Plane>& plane)
|
|
{
|
|
core::Ptr<BRepBody> res = planeIntersection_raw(body.get(), plane.get());
|
|
return res;
|
|
}
|
|
|
|
inline core::Ptr<BRepBody> TemporaryBRepManager::createRuledSurface(const core::Ptr<BRepWire>& sectionOne, const core::Ptr<BRepWire>& sectionTwo)
|
|
{
|
|
core::Ptr<BRepBody> res = createRuledSurface_raw(sectionOne.get(), sectionTwo.get());
|
|
return res;
|
|
}
|
|
|
|
inline core::Ptr<BRepBody> TemporaryBRepManager::createSilhouetteCurves(const core::Ptr<BRepFace>& face, const core::Ptr<core::Vector3D>& viewDirection, bool returnCoincidentSilhouettes)
|
|
{
|
|
core::Ptr<BRepBody> res = createSilhouetteCurves_raw(face.get(), viewDirection.get(), returnCoincidentSilhouettes);
|
|
return res;
|
|
}
|
|
|
|
inline bool TemporaryBRepManager::deleteFaces(const std::vector<core::Ptr<BRepFace>>& faces, bool deleteSpecifiedFaces)
|
|
{
|
|
BRepFace** faces_ = new BRepFace*[faces.size()];
|
|
for(size_t i=0; i<faces.size(); ++i)
|
|
faces_[i] = faces[i].get();
|
|
|
|
bool res = deleteFaces_raw(faces_, faces.size(), deleteSpecifiedFaces);
|
|
delete[] faces_;
|
|
return res;
|
|
}
|
|
|
|
inline bool TemporaryBRepManager::booleanOperation(const core::Ptr<BRepBody>& targetBody, const core::Ptr<BRepBody>& toolBody, BooleanTypes booleanType)
|
|
{
|
|
bool res = booleanOperation_raw(targetBody.get(), toolBody.get(), booleanType);
|
|
return res;
|
|
}
|
|
|
|
inline bool TemporaryBRepManager::transform(const core::Ptr<BRepBody>& body, const core::Ptr<core::Matrix3D>& transform)
|
|
{
|
|
bool res = transform_raw(body.get(), transform.get());
|
|
return res;
|
|
}
|
|
|
|
inline core::Ptr<BRepBodies> TemporaryBRepManager::createFromFile(const std::string& filename)
|
|
{
|
|
core::Ptr<BRepBodies> res = createFromFile_raw(filename.c_str());
|
|
return res;
|
|
}
|
|
|
|
inline bool TemporaryBRepManager::exportToFile(const std::vector<core::Ptr<BRepBody>>& bodies, const std::string& filename)
|
|
{
|
|
BRepBody** bodies_ = new BRepBody*[bodies.size()];
|
|
for(size_t i=0; i<bodies.size(); ++i)
|
|
bodies_[i] = bodies[i].get();
|
|
|
|
bool res = exportToFile_raw(bodies_, bodies.size(), filename.c_str());
|
|
delete[] bodies_;
|
|
return res;
|
|
}
|
|
|
|
inline core::Ptr<BRepBody> TemporaryBRepManager::createBox(const core::Ptr<core::OrientedBoundingBox3D>& box)
|
|
{
|
|
core::Ptr<BRepBody> res = createBox_raw(box.get());
|
|
return res;
|
|
}
|
|
|
|
inline core::Ptr<BRepBody> TemporaryBRepManager::createCylinderOrCone(const core::Ptr<core::Point3D>& pointOne, double pointOneRadius, const core::Ptr<core::Point3D>& pointTwo, double pointTwoRadius)
|
|
{
|
|
core::Ptr<BRepBody> res = createCylinderOrCone_raw(pointOne.get(), pointOneRadius, pointTwo.get(), pointTwoRadius);
|
|
return res;
|
|
}
|
|
|
|
inline core::Ptr<BRepBody> TemporaryBRepManager::createEllipticalCylinderOrCone(const core::Ptr<core::Point3D>& pointOne, double pointOneMajorRadius, double pointOneMinorRadius, const core::Ptr<core::Point3D>& pointTwo, double pointTwoMajorRadius, const core::Ptr<core::Vector3D>& majorAxisDirection)
|
|
{
|
|
core::Ptr<BRepBody> res = createEllipticalCylinderOrCone_raw(pointOne.get(), pointOneMajorRadius, pointOneMinorRadius, pointTwo.get(), pointTwoMajorRadius, majorAxisDirection.get());
|
|
return res;
|
|
}
|
|
|
|
inline core::Ptr<BRepBody> TemporaryBRepManager::createSphere(const core::Ptr<core::Point3D>& center, double radius)
|
|
{
|
|
core::Ptr<BRepBody> res = createSphere_raw(center.get(), radius);
|
|
return res;
|
|
}
|
|
|
|
inline core::Ptr<BRepBody> TemporaryBRepManager::createTorus(const core::Ptr<core::Point3D>& center, const core::Ptr<core::Vector3D>& axis, double majorRadius, double minorRadius)
|
|
{
|
|
core::Ptr<BRepBody> res = createTorus_raw(center.get(), axis.get(), majorRadius, minorRadius);
|
|
return res;
|
|
}
|
|
|
|
inline core::Ptr<BRepBody> TemporaryBRepManager::createFaceFromPlanarWires(const std::vector<core::Ptr<BRepBody>>& wireBodies)
|
|
{
|
|
BRepBody** wireBodies_ = new BRepBody*[wireBodies.size()];
|
|
for(size_t i=0; i<wireBodies.size(); ++i)
|
|
wireBodies_[i] = wireBodies[i].get();
|
|
|
|
core::Ptr<BRepBody> res = createFaceFromPlanarWires_raw(wireBodies_, wireBodies.size());
|
|
delete[] wireBodies_;
|
|
return res;
|
|
}
|
|
|
|
inline bool TemporaryBRepManager::imprintOverlapBodies(const core::Ptr<BRepBody>& bodyOne, const core::Ptr<BRepBody>& bodyTwo, bool imprintCoincidentEdges, core::Ptr<BRepBody>& resultBodyOne, core::Ptr<BRepBody>& resultBodyTwo, std::vector<core::Ptr<BRepFace>>& bodyOneOverlappingFaces, std::vector<core::Ptr<BRepFace>>& bodyTwoOverlappingFaces, std::vector<core::Ptr<BRepEdge>>& bodyOneOverlappingEdges, std::vector<core::Ptr<BRepEdge>>& bodyTwoOverlappingEdges, double tolerance)
|
|
{
|
|
BRepBody* resultBodyOne_ = nullptr;
|
|
BRepBody* resultBodyTwo_ = nullptr;
|
|
BRepFace** bodyOneOverlappingFaces_ = nullptr;
|
|
size_t bodyOneOverlappingFaces_size;
|
|
BRepFace** bodyTwoOverlappingFaces_ = nullptr;
|
|
size_t bodyTwoOverlappingFaces_size;
|
|
BRepEdge** bodyOneOverlappingEdges_ = nullptr;
|
|
size_t bodyOneOverlappingEdges_size;
|
|
BRepEdge** bodyTwoOverlappingEdges_ = nullptr;
|
|
size_t bodyTwoOverlappingEdges_size;
|
|
|
|
bool res = imprintOverlapBodies_raw(bodyOne.get(), bodyTwo.get(), imprintCoincidentEdges, resultBodyOne_, resultBodyTwo_, bodyOneOverlappingFaces_, bodyOneOverlappingFaces_size, bodyTwoOverlappingFaces_, bodyTwoOverlappingFaces_size, bodyOneOverlappingEdges_, bodyOneOverlappingEdges_size, bodyTwoOverlappingEdges_, bodyTwoOverlappingEdges_size, tolerance);
|
|
resultBodyOne = resultBodyOne_;
|
|
resultBodyTwo = resultBodyTwo_;
|
|
if(bodyOneOverlappingFaces_)
|
|
{
|
|
bodyOneOverlappingFaces.assign(bodyOneOverlappingFaces_, bodyOneOverlappingFaces_ + bodyOneOverlappingFaces_size);
|
|
core::DeallocateArray(bodyOneOverlappingFaces_);
|
|
}
|
|
if(bodyTwoOverlappingFaces_)
|
|
{
|
|
bodyTwoOverlappingFaces.assign(bodyTwoOverlappingFaces_, bodyTwoOverlappingFaces_ + bodyTwoOverlappingFaces_size);
|
|
core::DeallocateArray(bodyTwoOverlappingFaces_);
|
|
}
|
|
if(bodyOneOverlappingEdges_)
|
|
{
|
|
bodyOneOverlappingEdges.assign(bodyOneOverlappingEdges_, bodyOneOverlappingEdges_ + bodyOneOverlappingEdges_size);
|
|
core::DeallocateArray(bodyOneOverlappingEdges_);
|
|
}
|
|
if(bodyTwoOverlappingEdges_)
|
|
{
|
|
bodyTwoOverlappingEdges.assign(bodyTwoOverlappingEdges_, bodyTwoOverlappingEdges_ + bodyTwoOverlappingEdges_size);
|
|
core::DeallocateArray(bodyTwoOverlappingEdges_);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
inline core::Ptr<BRepBody> TemporaryBRepManager::createWireFromCurves(const std::vector<core::Ptr<core::Curve3D>>& curves, std::vector<core::Ptr<BRepEdge>>& edgeMap, bool allowSelfIntersections)
|
|
{
|
|
core::Curve3D** curves_ = new core::Curve3D*[curves.size()];
|
|
for(size_t i=0; i<curves.size(); ++i)
|
|
curves_[i] = curves[i].get();
|
|
BRepEdge** edgeMap_ = nullptr;
|
|
size_t edgeMap_size;
|
|
|
|
core::Ptr<BRepBody> res = createWireFromCurves_raw(curves_, curves.size(), edgeMap_, edgeMap_size, allowSelfIntersections);
|
|
delete[] curves_;
|
|
if(edgeMap_)
|
|
{
|
|
edgeMap.assign(edgeMap_, edgeMap_ + edgeMap_size);
|
|
core::DeallocateArray(edgeMap_);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
inline core::Ptr<BRepBody> TemporaryBRepManager::createHelixWire(const core::Ptr<core::Point3D>& axisPoint, const core::Ptr<core::Vector3D>& axisVector, const core::Ptr<core::Point3D>& startPoint, double pitch, double turns, double taperAngle)
|
|
{
|
|
core::Ptr<BRepBody> res = createHelixWire_raw(axisPoint.get(), axisVector.get(), startPoint.get(), pitch, turns, taperAngle);
|
|
return res;
|
|
}
|
|
}// namespace fusion
|
|
}// namespace adsk
|
|
|
|
#undef ADSK_FUSION_TEMPORARYBREPMANAGER_API |