void HDimension::glCommands(bool select, bool marked, bool no_color)
{
gp_Pnt b = GetB2();
if(A->m_p.IsEqual(b, wxGetApp().m_geom_tol))return;
if(!no_color)wxGetApp().glColorEnsuringContrast(m_color);
gp_Dir xdir = gp_Dir(1, 0, 0).Transformed(m_trsf);
gp_Dir ydir = gp_Dir(0, 1, 0).Transformed(m_trsf);
gp_Dir zdir = gp_Dir(0, 0, 1).Transformed(m_trsf);
if(m_mode == TwoPointsDimensionMode || m_mode == TwoPointsXYOnlyDimensionMode || m_mode == TwoPointsXOnlyDimensionMode)
{
xdir = make_vector(A->m_p, b);
if(xdir.IsParallel(zdir,wxGetApp().m_geom_tol))
zdir = xdir ^ ydir;
else
ydir = zdir ^ xdir;
}
wxString text = MakeText();
float width, height;
if(!wxGetApp().get_text_size(text, &width, &height))return;
// draw arrow line
draw_arrow_line(m_mode, A->m_p, b, GetC2(), xdir, ydir, width, m_scale);
// draw text
RenderText(text, GetC2(), xdir, ydir, m_scale);
EndedObject::glCommands(select,marked,no_color);
}
gp_Dir GetFaceNormalAtUV(const TopoDS_Face &face, double u, double v, gp_Pnt *pos){
if(face.IsNull()) return gp_Dir(0, 0, 1);
try
{
Handle(Geom_Surface) surf=BRep_Tool::Surface(face); // get surface properties
GeomLProp_SLProps props(surf, u, v, 1, 0.01); // get surface normal
if(!props.IsNormalDefined())return gp_Dir(0, 0, 1);
gp_Dir norm=props.Normal(); // check orientation
if(pos)*pos = props.Value();
if(face.Orientation()==TopAbs_REVERSED) norm.Reverse();
return norm;
}
catch (Standard_Failure) {
Handle_Standard_Failure e = Standard_Failure::Caught();
wxMessageBox(wxString(_("Error in GetFaceNormalAtUV")) + _T(": ") + Ctt(e->GetMessageString()));
return gp_Dir(0, 0, 1);
}
catch (const char* str)
{
wxMessageBox(wxString(_("Error in GetFaceNormalAtUV")) + _T(": ") + Ctt(str));
return gp_Dir(0, 0, 1);
}
catch (...)
{
wxMessageBox(_("Error in GetFaceNormalAtUV"));
return gp_Dir(0, 0, 1);
}
}
PNamedShape CTiglAbstractGeometricComponent::GetMirroredLoft(void)
{
if (mySymmetryAxis == TIGL_NO_SYMMETRY) {
PNamedShape nullShape;
nullShape.reset();
return nullShape;
}
gp_Ax2 mirrorPlane;
if (mySymmetryAxis == TIGL_X_Z_PLANE) {
mirrorPlane = gp_Ax2(gp_Pnt(0,0,0),gp_Dir(0.,1.,0.));
}
else if (mySymmetryAxis == TIGL_X_Y_PLANE) {
mirrorPlane = gp_Ax2(gp_Pnt(0,0,0),gp_Dir(0.,0.,1.));
}
else if (mySymmetryAxis == TIGL_Y_Z_PLANE) {
mirrorPlane = gp_Ax2(gp_Pnt(0,0,0),gp_Dir(1.,0.,0.));
}
gp_Trsf theTransformation;
theTransformation.SetMirror(mirrorPlane);
BRepBuilderAPI_Transform myBRepTransformation(GetLoft()->Shape(), theTransformation);
std::string mirrorName = GetLoft()->Name();
mirrorName += "M";
std::string mirrorShortName = GetLoft()->ShortName();
mirrorShortName += "M";
TopoDS_Shape mirroredShape = myBRepTransformation.Shape();
PNamedShape mirroredPNamedShape(new CNamedShape(*GetLoft()));
mirroredPNamedShape->SetShape(mirroredShape);
mirroredPNamedShape->SetName(mirrorName.c_str());
mirroredPNamedShape->SetShortName(mirrorShortName.c_str());
return mirroredPNamedShape;
}
//================================================================
// Function : TexturesExt_Presentation::sampleLand
// Purpose :
//================================================================
void TexturesExt_Presentation::sampleTerrain()
{
TopoDS_Shape aShape;
if (!loadShape(aShape, "terrain.brep"))
return;
// a part of the landscape is textured
TopTools_IndexedMapOfShape aFaces;
TopExp::MapShapes(aShape, TopAbs_FACE, aFaces);
// TopLoc_Location aLoc;
// Handle_Geom_Surface aSur = BRep_Tool::Surface(TopoDS::Face(aFaces(1)), aLoc);
// Standard_Real u1,u2,v1,v2;
// aSur->Bounds(u1,u2,v1,v2);
// gp_Pnt aPnt = aSur->Value(u1, v1);
gp_Pnt aPnt(82100,80300,10940);// point at u1,v1
// resize and move the shape to the center of the viewer
gp_Trsf aMoveTrsf;
gp_Ax3 New(gp_Pnt(-30,-30, 0),gp_Dir(0,0,1));
gp_Ax3 Current(aPnt,gp_Dir(0,0,1));
aMoveTrsf.SetDisplacement(Current, New);
gp_Trsf aScaleTrsf;
aScaleTrsf.SetScale(aPnt,0.0075);
BRepBuilderAPI_Transform aTransform(aMoveTrsf*aScaleTrsf);
aTransform.Perform(aFaces(1));
aShape = aTransform;
getAISContext()->Display(Texturize(aShape, "terrain.gif"));
}
bool IfcGeom::convert(const Ifc2x3::IfcAxis2Placement3D::ptr l, gp_Trsf& trsf) {
IN_CACHE(IfcAxis2Placement3D,l,gp_Trsf,trsf)
gp_Pnt o;gp_Dir axis = gp_Dir(0,0,1);gp_Dir refDirection;
IfcGeom::convert(l->Location(),o);
bool hasRef = l->hasRefDirection();
if ( l->hasAxis() ) IfcGeom::convert(l->Axis(),axis);
if ( hasRef ) IfcGeom::convert(l->RefDirection(),refDirection);
gp_Ax3 ax3;
if ( hasRef ) ax3 = gp_Ax3(o,axis,refDirection);
else ax3 = gp_Ax3(o,axis);
trsf.SetTransformation(ax3, gp_Ax3(gp_Pnt(),gp_Dir(0,0,1),gp_Dir(1,0,0)));
CACHE(IfcAxis2Placement3D,l,trsf)
return true;
}
void line_arc_line(double tooth_angle)
{
double gap = gap_width();
double radius = gap/3;
double clearance = gear_for_point->GetClearanceMM();
double line_length = clearance - radius;
if(line_length < 0.0)
{
line_length = 0.0;
radius = clearance;
}
gp_Pnt p1, p2, p1B, p2B;
get_clearance_points(p1, p2, tooth_angle, 0.0);
get_clearance_points(p1B, p2B, tooth_angle, line_length);
gp_Pnt pm = mid_point(tooth_angle, line_length);
gp_Circ c(gp_Ax2(pm, gp_Dir(0, 0, -1)), radius);
if(line_length >= wxGetApp().m_geom_tol)
sketch_for_gear->Add(new HLine(p1, p1B, &wxGetApp().current_color), NULL);
double mid_span_line_length = gap - 2*radius;
if(mid_span_line_length >= wxGetApp().m_geom_tol)
{
gp_Vec v(p1, p2);
v.Normalize();
gp_Pnt p1C, p2C;
get_clearance_points(p1C, p2C, tooth_angle, clearance);
gp_Pnt two_arc_p1 = gp_Pnt(p1C.XYZ() + v.XYZ() * radius);
gp_Pnt two_arc_p2 = gp_Pnt(two_arc_p1.XYZ() + v.XYZ() * mid_span_line_length);
gp_Pnt pm1 = gp_Pnt(p1B.XYZ() + v.XYZ() * radius);
gp_Pnt pm2 = gp_Pnt(pm1.XYZ() + v.XYZ() * mid_span_line_length);
gp_Circ c1(gp_Ax2(pm1, gp_Dir(0, 0, -1)), radius);
gp_Circ c2(gp_Ax2(pm2, gp_Dir(0, 0, -1)), radius);
sketch_for_gear->Add(new HArc(p1B, two_arc_p1, c1, &wxGetApp().current_color), NULL);
sketch_for_gear->Add(new HLine(two_arc_p1, two_arc_p2, &wxGetApp().current_color), NULL);
sketch_for_gear->Add(new HArc(two_arc_p2, p2B, c2, &wxGetApp().current_color), NULL);
}
else
{
sketch_for_gear->Add(new HArc(p1B, p2B, c, &wxGetApp().current_color), NULL);
}
if(line_length >= wxGetApp().m_geom_tol)
sketch_for_gear->Add(new HLine(p2B, p2, &wxGetApp().current_color), NULL);
spline_points_for_gear.clear();
spline_points_for_gear.push_back(p2);
}
//================================================================
// Function : moveScale
// Purpose : move a shape a little left and scale it to 15%.
//================================================================
static void moveScale(TopoDS_Shape& aShape)
{
gp_Trsf aMoveTrsf;
gp_Ax3 New(gp_Pnt(-30,-30, -10),gp_Dir(0,0,1));
gp_Ax3 Current(gp_Pnt(0,0,0),gp_Dir(0,0,1));
aMoveTrsf.SetDisplacement(Current, New);
gp_Trsf aScaleTrsf;
aScaleTrsf.SetScale(gp_Pnt(0,0,0),0.15);
BRepBuilderAPI_Transform aTransform(aMoveTrsf*aScaleTrsf);
aTransform.Perform(aShape);
aShape = aTransform;
}
/*!
\brief Sets the privileged plane to the XY Axis.
*/
void QoccViewerContext::gridYZ ( void )
{
myGridColor = Quantity_NOC_GREEN4;
myViewer->Grid()->SetColors( myGridColor, myGridTenthColor );
gp_Ax3 aPlane( gp_Pnt( 0., 0., 0.), gp_Dir( 1., 0., 0. ) );
myViewer->SetPrivilegedPlane( aPlane );
}
//================================================================
// Function : Convert_Presentation::sampleConicalSurface
// Purpose :
//================================================================
void Convert_Presentation::sampleConicalSurface()
{
getAISContext()->EraseAll();
Standard_CString aName = "Conical surface";
TCollection_AsciiString aText (
" // creating an axis parallel to Z axis" EOL
" gp_Ax3 anAx(gp_Pnt(0,0,0), gp_Dir(0,0,1)); " EOL
" // creating a conical surface with base radius = 10 and angle = 20 deg" EOL
" Handle(Geom_ConicalSurface) aConicalSurface = new Geom_ConicalSurface(anAx,PI/9., 10);" EOL EOL
" // only finit surfaces can be converted to BSpline surfaces, " EOL
" // conical surface is infinite, it must be trimmed" EOL
" Handle(Geom_RectangularTrimmedSurface) aSurface = " EOL
" new Geom_RectangularTrimmedSurface(aConicalSurface, 0, 2*PI, -1000, 1000, Standard_True, Standard_True);" EOL);
// creating an axis parallel to Z axis
gp_Ax3 anAx(gp_Pnt(0,0,0), gp_Dir(0,0,1));
// creating a conical surface with base radius = 10 and angle = 20 deg
Handle(Geom_ConicalSurface) aConicalSurface = new Geom_ConicalSurface(anAx,M_PI/9., 10);
// only finit surfaces can be converted to BSpline surfaces,
// conical surface is infinite, it must be trimmed
Handle(Geom_RectangularTrimmedSurface) aSurface =
new Geom_RectangularTrimmedSurface(aConicalSurface, 0, 2*M_PI, -1000, 1000, Standard_True, Standard_True);
drawSurfaceAndItsBSpline(aSurface, aName, aText);
}
/**
* Sample implementation of the method which handles arc entities.
*/
void DXFReader::addArc(const DL_ArcData& data)
{
gp_Pnt p1(data.cx, data.cy, data.cz);
gp_Ax2 a2(p1, gp_Dir(0, 0, 1));
gp_Circ c(a2, data.radius);
TopoDS_Shape arc = BRepBuilderAPI_MakeEdge(c, DEGTORAD(data.angle1), DEGTORAD(data.angle2)).Shape();
m_mainClass->draw(arc);
/*
gp_Pnt p1(data.cx, data.cy, data.cz);
gp_Ax2 a2(p1, gp_Dir(0, 0, 1));
gp_Circ circle(a2, data.radius);
GC_MakeArcOfCircle geoArc(circle, data.angle1, data.angle2, true);
TopoDS_Shape arc = BRepBuilderAPI_MakeEdge(geoArc.Value()).Shape();
m_mainClass->draw(arc);
qDebug() << data.angle1;
qDebug() << data.angle2;
*/
/*printf("ARC (%6.3f, %6.3f, %6.3f) %6.3f, %6.3f, %6.3f\n",
data.cx, data.cy, data.cz,
data.radius, data.angle1, data.angle2);*/
printAttributes();
}
void HeeksDxfRead::OnReadInsert(const char* block_name, const double* insert_point, double rotation_angle)
{
if (m_blocks.find( wxString(Ctt(block_name)) ) == m_blocks.end())
{
return; // block not foundblock_name, const double* insert_point, double rotation_angle
}
else
{
BlockName_t b_name = wxString(Ctt(block_name));
#if 0
// insert an insert object. To be expanded at the end
HInsert* new_object = new HInsert(block_name, insert_point, rotation_angle);
AddObject(new_object);
#else
CSketch* block = m_blocks[b_name];
CSketch* block_copy = new CSketch(*block);
gp_Trsf tm;
tm.SetTranslationPart(make_vector(insert_point));
gp_Trsf rm;
rm.SetRotation(gp_Ax1(gp_Pnt(0, 0, 0), gp_Dir(0, 0, 1)), rotation_angle * 0.01745329251994329);
double m[16];
extract(tm * rm, m);
block_copy->ModifyByMatrix(m);
AddObject(block_copy);
#endif
inserted_blocks.insert(b_name);
}
}
ISession_Direction::ISession_Direction (const gp_Pnt2d& aPnt2d,
const gp_Vec2d& aVec2d)
: myPnt (gp_Pnt (aPnt2d.X(), aPnt2d.Y(), 0.0)),
myDir (gp_Dir(aVec2d.X(), aVec2d.Y(), 0.0))
{
myLength = aVec2d.Magnitude();
myArrowLength = myDrawer->ArrowAspect()->Length();
}
ISession_Direction::ISession_Direction (const gp_Pnt2d& aPnt2d,
const gp_Dir2d& aDir2d,
Standard_Real aLength)
: myPnt (gp_Pnt(aPnt2d.X(),aPnt2d.Y(),0.0)),
myDir (gp_Dir(aDir2d.X(),aDir2d.Y(),0.0)),
myLength (aLength)
{
myArrowLength = myDrawer->ArrowAspect()->Length();
}
void HeeksDxfRead::OnReadDimension(int dimension_type, double angle, double angle2, double angle3, double radius_leader_length, const double *def_point, const double *mid, const double *p1, const double *p2, const double *p3, const double *p4, const double *p5)
{
int type = (dimension_type & 0x07);
gp_Pnt d = make_point(def_point);
gp_Pnt m = make_point(mid);
gp_Vec d_to_m = make_vector(d, m);
gp_Pnt e = gp_Pnt(m.XYZ() + d_to_m.XYZ());
gp_Dir forward(1,0,0);
HeeksColor c(0, 0, 0);
if(type == 0)
{
forward.Rotate(gp_Ax1(gp_Pnt(0, 0, 0), gp_Dir(0, 0, 1)), (angle/* + angle2 + angle3*/) * -0.01745329251);
}
else
{
forward = gp_Dir(-d_to_m);
c = HeeksColor(255, 0, 0);
}
gp_Dir left(-forward.Y(), forward.X(), 0.0);
double arrow_size = 5.0;
gp_Pnt da1 = d.XYZ() + forward.XYZ() * (-arrow_size) + left.XYZ() * (arrow_size * 0.25);
gp_Pnt da2 = d.XYZ() + forward.XYZ() * (-arrow_size) + left.XYZ() * (arrow_size * -0.25);
gp_Pnt ea1 = e.XYZ() + forward.XYZ() * (arrow_size) + left.XYZ() * (arrow_size * 0.25);
gp_Pnt ea2 = e.XYZ() + forward.XYZ() * (arrow_size) + left.XYZ() * (arrow_size * -0.25);
AddObject(new HLine(d, da1, &c));
AddObject(new HLine(da1, da2, &c));
AddObject(new HLine(da2, d, &c));
AddObject(new HLine(e, ea1, &c));
AddObject(new HLine(ea1, ea2, &c));
AddObject(new HLine(ea2, e, &c));
}
gp_Dir PositionSettingsWidget::getDirection() const
{
if (cbDirection->currentIndex() == 0)
return gp::DX();
if (cbDirection->currentIndex() == 1)
return gp::DY();
if (cbDirection->currentIndex() == 2)
return gp::DZ();
return gp_Dir();
}
bool IfcGeom::convert(const Ifc2x3::IfcDirection::ptr l, gp_Dir& dir) {
IN_CACHE(IfcDirection,l,gp_Dir,dir)
std::vector<double> xyz = l->DirectionRatios();
dir = gp_Dir(
xyz.size() ? xyz[0] : 0.0f,
xyz.size() > 1 ? xyz[1] : 0.0f,
xyz.size() > 2 ? xyz[2] : 0.0f
);
CACHE(IfcDirection,l,dir)
return true;
}
gp_Pln Feature::makePlnFromPlane(const App::DocumentObject* obj)
{
const App::GeoFeature* plane = static_cast<const App::GeoFeature*>(obj);
if (plane == NULL)
throw Base::Exception("Feature: Null object");
Base::Vector3d pos = plane->Placement.getValue().getPosition();
Base::Rotation rot = plane->Placement.getValue().getRotation();
Base::Vector3d normal(0,0,1);
rot.multVec(normal, normal);
return gp_Pln(gp_Pnt(pos.x,pos.y,pos.z), gp_Dir(normal.x,normal.y,normal.z));
}
//================================================================
// Function : OCCDemo_Presentation::sampleRevolSurface
// Purpose :
//================================================================
void Convert_Presentation::sampleRevolSurface()
{
FitMode=false;
ResetView();
SetViewCenter(176.84682,102.12892);
SetViewScale(0.69326);
getAISContext()->EraseAll();
Standard_CString aName = "Surface of revolution";
TCollection_AsciiString aText (
" // creating a curve for revolution. Let it be a Bezier curve." EOL
" Handle(Geom_BezierCurve) aBezierCurve;" EOL EOL
" // array of the bezier curve poles" EOL
" TColgp_Array1OfPnt aPoles(1,4);" EOL
" // array of the poles' weights" EOL
" TColStd_Array1OfReal aWeights(1,4);" EOL EOL
" aPoles(1) = gp_Pnt(0, 0, 0); aWeights(1) = 1;" EOL
" aPoles(2) = gp_Pnt(150, 250, 0); aWeights(2) =75;" EOL
" aPoles(3) = gp_Pnt(350, 150, 0); aWeights(3) =120;" EOL
" aPoles(4) = gp_Pnt(500, 500, 0); aWeights(4) = 1;" EOL EOL
" // creating a bezier curve" EOL
" aBezierCurve = new Geom_BezierCurve(aPoles, aWeights);" EOL EOL
" // creating a surface of revolution of the bezier curve around Y axis" EOL
" gp_Ax1 anAx(gp_Pnt(0, 0, 0), gp_Dir(0,1,0));" EOL
" Handle(Geom_SurfaceOfRevolution) aSurface = new Geom_SurfaceOfRevolution(aBezierCurve, anAx);" EOL
);
// array of the bezier curve poles
TColgp_Array1OfPnt aPoles(1,4);
// array of the poles' weights
TColStd_Array1OfReal aWeights(1,4);
aPoles(1) = gp_Pnt(0, 0, 0); aWeights(1) = 1;
aPoles(2) = gp_Pnt(150, 250, 0); aWeights(2) =75;
aPoles(3) = gp_Pnt(350, 150, 0); aWeights(3) =120;
aPoles(4) = gp_Pnt(500, 500, 0); aWeights(4) = 1;
Handle(Geom_BezierCurve) aBezierCurve = new Geom_BezierCurve(aPoles, aWeights);
drawCurve(aBezierCurve);
// creating a surface of revolution of the bezier curve around Y axis
gp_Ax1 anAx(gp_Pnt(0,0,0), gp_Dir(0,1,0));
Handle(Geom_SurfaceOfRevolution) aSurface = new Geom_SurfaceOfRevolution(aBezierCurve, anAx);
drawSurfaceAndItsBSpline (aSurface, aName, aText);
FitMode=true;
}
gp_Pnt HDimension::GetC2()
{
// return m_p2, possibly flattened
if(m_mode == TwoPointsXYOnlyDimensionMode || m_mode == TwoPointsXOnlyDimensionMode)
{
gp_Dir zdir = gp_Dir(0, 0, 1).Transformed(m_trsf);
double dp = gp_Vec(m_p2->m_p.XYZ()) * zdir - gp_Vec(A->m_p.XYZ()) * zdir;
return gp_Pnt(m_p2->m_p.XYZ() + zdir.XYZ() * (-dp));
}
#if 0
else if(m_mode == TwoPointsXOnlyDimensionMode)
{
gp_Dir zdir = gp_Dir(0, 0, 1).Transformed(m_trsf);
double zdp = gp_Vec(m_p2->m_p.XYZ()) * zdir - gp_Vec(A->m_p.XYZ()) * zdir;
gp_Dir ydir = gp_Dir(0, 1, 0).Transformed(m_trsf);
double ydp = gp_Vec(m_p2->m_p.XYZ()) * ydir - gp_Vec(A->m_p.XYZ()) * ydir;
return gp_Pnt(m_p2->m_p.XYZ() + zdir.XYZ() * (-zdp) + ydir.XYZ() * (-ydp));
}
#endif
return m_p2->m_p;
}
// static member function
HeeksObj* HGear::ReadFromXMLElement(TiXmlElement* element)
{
HGear* new_object = new HGear();
element->Attribute("num_teeth", &new_object->m_num_teeth);
element->Attribute("module", &new_object->m_module);
element->Attribute("addendum_offset", &new_object->m_addendum_offset);
element->Attribute("addendum_multiplier", &new_object->m_addendum_multiplier);
element->Attribute("dedendum_multiplier", &new_object->m_dedendum_multiplier);
element->Attribute("pressure_angle", &new_object->m_pressure_angle);
element->Attribute("tip_relief", &new_object->m_tip_relief);
element->Attribute("depth", &new_object->m_depth);
element->Attribute("cone_half_angle", &new_object->m_cone_half_angle);
element->Attribute("drawn_angle", &new_object->m_angle);
double l[3] = {0.0, 0.0, 0.0};
double d[3] = {0.0, 0.0, 1.0};
double x[3] = {1.0, 0.0, 0.0};
element->Attribute("lx", &l[0]);
element->Attribute("ly", &l[1]);
element->Attribute("lz", &l[2]);
element->Attribute("dx", &d[0]);
element->Attribute("dy", &d[1]);
element->Attribute("dz", &d[2]);
element->Attribute("xx", &x[0]);
element->Attribute("xy", &x[1]);
element->Attribute("xz", &x[2]);
new_object->m_pos = gp_Ax2(gp_Pnt(l[0], l[1], l[2]), gp_Dir(d[0], d[1], d[2]), gp_Dir(x[0], x[1], x[2]));
new_object->ReadBaseXML(element);
return new_object;
}
/**
* Sample implementation of the method which handles circle entities.
*/
void DXFReader::addCircle(const DL_CircleData& data) {
qDebug() << "addcircle";
gp_Pnt p1(data.cx, data.cy, data.cz);
gp_Ax2 a2(p1, gp_Dir(0, 0, 1));
gp_Circ c(a2, data.radius);
TopoDS_Shape circle = BRepBuilderAPI_MakeEdge(c).Shape();
m_mainClass->draw(circle, Standard_False);
/*printf("CIRCLE (%6.3f, %6.3f, %6.3f) %6.3f\n",
data.cx, data.cy, data.cz,
data.radius);
printAttributes();*/
}
bool IfcGeom::convert(const Ifc2x3::IfcPlane::ptr pln, gp_Pln& plane) {
IN_CACHE(IfcPlane,pln,gp_Pln,plane)
Ifc2x3::IfcAxis2Placement3D::ptr l = pln->Position();
gp_Pnt o;gp_Dir axis = gp_Dir(0,0,1);gp_Dir refDirection;
IfcGeom::convert(l->Location(),o);
bool hasRef = l->hasRefDirection();
if ( l->hasAxis() ) IfcGeom::convert(l->Axis(),axis);
if ( hasRef ) IfcGeom::convert(l->RefDirection(),refDirection);
gp_Ax3 ax3;
if ( hasRef ) ax3 = gp_Ax3(o,axis,refDirection);
else ax3 = gp_Ax3(o,axis);
plane = gp_Pln(ax3);
CACHE(IfcPlane,pln,plane)
return true;
}
bool PCBMODEL::getModelLocation( bool aBottom, DOUBLET aPosition, double aRotation,
TRIPLET aOffset, TRIPLET aOrientation, TopLoc_Location& aLocation )
{
// Order of operations:
// a. aOrientation is applied -Z*-Y*-X
// b. aOffset is applied
// Top ? add thickness to the Z offset
// c. Bottom ? Rotate on X axis (in contrast to most ECAD which mirror on Y),
// then rotate on +Z
// Top ? rotate on -Z
// d. aPosition is applied
//
// Note: Y axis is inverted in KiCad
gp_Trsf lPos;
lPos.SetTranslation( gp_Vec( aPosition.x, -aPosition.y, 0.0 ) );
// offset (inches)
aOffset.x *= 25.4;
aOffset.y *= 25.4;
aOffset.z *= 25.4 + BOARD_OFFSET;
gp_Trsf lRot;
if( aBottom )
{
lRot.SetRotation( gp_Ax1( gp_Pnt( 0.0, 0.0, 0.0 ), gp_Dir( 0.0, 0.0, 1.0 ) ), aRotation );
lPos.Multiply( lRot );
lRot.SetRotation( gp_Ax1( gp_Pnt( 0.0, 0.0, 0.0 ), gp_Dir( 1.0, 0.0, 0.0 ) ), M_PI );
lPos.Multiply( lRot );
}
else
{
aOffset.z += m_thickness;
lRot.SetRotation( gp_Ax1( gp_Pnt( 0.0, 0.0, 0.0 ), gp_Dir( 0.0, 0.0, 1.0 ) ), aRotation );
lPos.Multiply( lRot );
}
gp_Trsf lOff;
lOff.SetTranslation( gp_Vec( aOffset.x, aOffset.y, aOffset.z ) );
lPos.Multiply( lOff );
gp_Trsf lOrient;
lOrient.SetRotation( gp_Ax1( gp_Pnt( 0.0, 0.0, 0.0 ),
gp_Dir( 0.0, 0.0, 1.0 ) ), -aOrientation.z );
lPos.Multiply( lOrient );
lOrient.SetRotation( gp_Ax1( gp_Pnt( 0.0, 0.0, 0.0 ),
gp_Dir( 0.0, 1.0, 0.0 ) ), -aOrientation.y );
lPos.Multiply( lOrient );
lOrient.SetRotation( gp_Ax1( gp_Pnt( 0.0, 0.0, 0.0 ),
gp_Dir( 1.0, 0.0, 0.0 ) ), -aOrientation.x );
lPos.Multiply( lOrient );
aLocation = TopLoc_Location( lPos );
return true;
}
//================================================================
// Function : Convert_Presentation::sampleSphericalSurface
// Purpose :
//================================================================
void Convert_Presentation::sampleSphericalSurface()
{
getAISContext()->EraseAll();
Standard_CString aName = "Spherical surface";
TCollection_AsciiString aText (
"// creating an axis parallel to Z axis" EOL
"gp_Ax3 anAx(gp_Pnt(0,0,0), gp_Dir(0,0,1));" EOL
"// creating a spherical surface with radius = 300" EOL
"Handle(Geom_SphericalSurface) aSurface = new Geom_SphericalSurface(anAx,300);" EOL);
// creating an axis parallel to Z axis
gp_Ax3 anAx(gp_Pnt(0,0,0), gp_Dir(0,0,1));
// creating a spherical surface with radius = 300
Handle(Geom_SphericalSurface) aSurface = new Geom_SphericalSurface(anAx,300);
drawSurfaceAndItsBSpline(aSurface, aName, aText);
}
//================================================================
// Function : Convert_Presentation::sampleToroidalSurface
// Purpose :
//================================================================
void Convert_Presentation::sampleToroidalSurface()
{
getAISContext()->EraseAll();
Standard_CString aName = "Toroidal surface";
TCollection_AsciiString aText (
" // creating an axis parallel to Y axis" EOL
" gp_Ax3 anAx(gp_Pnt(0,0,0), gp_Dir(0,1,0));" EOL
" // creating a toroidal surface with major radius = 240 and minor radius = 120" EOL
" Handle(Geom_ToroidalSurface) aSurface = new Geom_ToroidalSurface(anAx, 240, 120);" EOL);
// creating an axis parallel to Y axis
gp_Ax3 anAx(gp_Pnt(0,0,0), gp_Dir(0,1,0));
// creating a toroidal surface with major radius = 240 and minor radius = 120
Handle(Geom_ToroidalSurface) aSurface = new Geom_ToroidalSurface(anAx, 240, 120);
drawSurfaceAndItsBSpline(aSurface, aName, aText);
}
void LVPS_GM2Displacement1Rotation::Calculate(LVPS_XYZNode* nodes)
{
double xi = (nodes[DisplacementNodeX.ID].S);
double yi = (nodes[DisplacementNodeY.ID].S);
gp_Vec vec;
vec = gp_Vec(1,0,0)*xi;
aTrsf.SetTranslation(vec);
vec = gp_Vec(0,1,0)*yi;
gp_Trsf trsf, trsf1;
trsf.SetTranslation(vec);
aTrsf=trsf*aTrsf;
Standard_Real X=x+nodes[DisplacementNodeX.ID].S;
Standard_Real Y=y+nodes[DisplacementNodeY.ID].S;
trsf1.SetRotation(gp_Ax1(gp_Pnt(X,Y,0),/*axisZ*/gp_Dir(0,0,1)),nodes[RotationNode.ID].S);
aTrsf=trsf1*aTrsf;
};
int OCCEdge::createEllipse(OCCStruct3d pnt, OCCStruct3d nor, double rMajor, double rMinor)
{
try {
gp_Ax2 ax2(gp_Pnt(pnt.x,pnt.y,pnt.z), gp_Dir(nor.x,nor.y,nor.z));
if (rMajor <= Precision::Confusion() || rMinor <= Precision::Confusion()) {
StdFail_NotDone::Raise("radius to small");
}
gce_MakeElips ellipse(ax2, rMajor, rMinor);
this->setShape(BRepBuilderAPI_MakeEdge(ellipse));
} catch(Standard_Failure &err) {
Handle_Standard_Failure e = Standard_Failure::Caught();
const Standard_CString msg = e->GetMessageString();
if (msg != NULL && strlen(msg) > 1) {
setErrorMessage(msg);
} else {
setErrorMessage("Failed to create ellipse");
}
return 0;
}
return 1;
}
void HGear::SetSegmentsVariables(void(*callbackfunc)(const double *p))const
{
callbackfunc_for_point = callbackfunc;
gear_for_point = this;
gp_Trsf rotation;
rotation.SetRotation(gp_Ax1(gp_Pnt(0, 0, 0), gp_Dir(0, 0, 1)), m_angle * M_PI/180);
mat_for_point = make_matrix(m_pos.Location(), m_pos.XDirection(), m_pos.YDirection());
mat_for_point = rotation.Multiplied(mat_for_point);
cone_sin_for_point = sin(m_cone_half_angle);
cone_cos_for_point = cos(m_cone_half_angle);
pitch_radius = (double)(m_module * m_num_teeth)/2;
inside_radius = pitch_radius - m_dedendum_multiplier*m_module;
outside_radius = pitch_radius + (m_addendum_multiplier*m_module + m_addendum_offset);
base_radius = pitch_radius * cos(gear_for_point->m_pressure_angle) / cos(gear_for_point->m_cone_half_angle);
if(inside_radius < base_radius)inside_radius = base_radius;
inside_phi_and_angle = involute_intersect(inside_radius);
outside_phi_and_angle = involute_intersect(outside_radius);
tip_relief_phi_and_angle = involute_intersect(outside_radius - m_tip_relief);
middle_phi_and_angle = involute_intersect(pitch_radius);
spline_points_for_gear.clear();
}
gp_Pnt HDimension::GetB2()
{
// return B, possibly flattened
if(m_mode == TwoPointsXYOnlyDimensionMode)
{
gp_Dir zdir = gp_Dir(0, 0, 1).Transformed(m_trsf);
double dp = gp_Vec(B->m_p.XYZ()) * zdir - gp_Vec(A->m_p.XYZ()) * zdir;
return gp_Pnt(B->m_p.XYZ() + zdir.XYZ() * (-dp));
}
else if(m_mode == TwoPointsXOnlyDimensionMode)
{
gp_Dir zdir = gp_Dir(0, 0, 1).Transformed(m_trsf);
gp_Dir ydir = gp_Dir(0, 1, 0).Transformed(m_trsf);
double dpz = gp_Vec(B->m_p.XYZ()) * zdir - gp_Vec(A->m_p.XYZ()) * zdir;
double dpy = gp_Vec(B->m_p.XYZ()) * ydir - gp_Vec(A->m_p.XYZ()) * ydir;
return gp_Pnt(B->m_p.XYZ() + zdir.XYZ() * (-dpz) + ydir.XYZ() * (-dpy));
}
else if(m_mode == TwoPointsYOnlyDimensionMode)
{
gp_Dir zdir = gp_Dir(0, 0, 1).Transformed(m_trsf);
gp_Dir xdir = gp_Dir(1, 0, 0).Transformed(m_trsf);
double dpz = gp_Vec(B->m_p.XYZ()) * zdir - gp_Vec(A->m_p.XYZ()) * zdir;
double dpx = gp_Vec(B->m_p.XYZ()) * xdir - gp_Vec(A->m_p.XYZ()) * xdir;
return gp_Pnt(B->m_p.XYZ() + zdir.XYZ() * (-dpz) + xdir.XYZ() * (-dpx));
}
else if(m_mode == TwoPointsZOnlyDimensionMode)
{
gp_Dir xdir = gp_Dir(1, 0, 0).Transformed(m_trsf);
gp_Dir ydir = gp_Dir(0, 1, 0).Transformed(m_trsf);
double dpx = gp_Vec(B->m_p.XYZ()) * xdir - gp_Vec(A->m_p.XYZ()) * xdir;
double dpy = gp_Vec(B->m_p.XYZ()) * ydir - gp_Vec(A->m_p.XYZ()) * ydir;
return gp_Pnt(B->m_p.XYZ() + xdir.XYZ() * (-dpx) + ydir.XYZ() * (-dpy));
}
return B->m_p;
}
//================================================================
// Function : TexturesExt_Presentation::sampleKitchen
// Purpose : kitchen with texturized items in it.
//================================================================
void TexturesExt_Presentation::sampleKitchen()
{
TopoDS_Shape aShape;
if (!loadShape(aShape, "Kitchen\\Room.brep"))
return;
gp_Trsf aTrsf;
gp_Ax3 NewCoordSystem (gp_Pnt(-1,-1, -1),gp_Dir(0,0,1));
gp_Ax3 CurrentCoordSystem(gp_Pnt(0,0,0),gp_Dir(0,0,1));
aTrsf.SetDisplacement(CurrentCoordSystem, NewCoordSystem);
aShape.Location(TopLoc_Location(aTrsf));
moveScale(aShape);
// draw kitchen room whithout one wall (to better see the insides)
TopTools_IndexedMapOfShape aFaces;
TopExp::MapShapes(aShape, TopAbs_FACE, aFaces);
Standard_Integer nbFaces = aFaces.Extent();
// create a wooden kitchen floor
// the floor's face will be textured with texture from chataignier.gif
DISP(Texturize(aFaces(5),"plancher.gif",1,1,2,1));
// texturize other faces of the room with texture from wallpaper.gif (walls)
DISP(Texturize(aFaces(1),"wallpaper.gif",1,1,8,6));
DISP(Texturize(aFaces(3),"wallpaper.gif",1,1,8,6));
DISP(Texturize(aFaces(4),"wallpaper.gif",1,1,8,6));
// DISP(drawShape(aFaces(1), Quantity_NOC_LIGHTPINK, Standard_False));
// DISP(drawShape(aFaces(3), Quantity_NOC_LIGHTPINK, Standard_False));
// DISP(drawShape(aFaces(4), Quantity_NOC_LIGHTPINK, Standard_False));
// texturize furniture items with "wooden" texture
if (loadShape(aShape, "Kitchen\\MODERN_Table_1.brep"))
{
moveScale(aShape);
DISP(Texturize(aShape, "chataignier.gif"));
}
if (loadShape(aShape, "Kitchen\\MODERN_Chair_1.brep"))
{
moveScale(aShape);
DISP(Texturize(aShape, "chataignier.gif"));
}
if (loadShape(aShape, "Kitchen\\MODERN_Cooker_1.brep"))
{
moveScale(aShape);
aFaces.Clear();
TopExp::MapShapes(aShape, TopAbs_FACE, aFaces);
nbFaces = aFaces.Extent();
for (Standard_Integer i = 1; i <= nbFaces; i++)
{
if (i >= 59)
DISP(drawShape(aFaces(i), Graphic3d_NOM_STEEL, Standard_False));
else if (i >= 29)
DISP(drawShape(aFaces(i), Graphic3d_NOM_ALUMINIUM, Standard_False));
else if (i == 28)
DISP(Texturize(aFaces(i), "cookerplate.gif"));
else
DISP(Texturize(aFaces(i), "chataignier.gif"));
}
}
if (loadShape(aShape, "Kitchen\\MODERN_Cooker_1_opened.brep"))
{
moveScale(aShape);
DISP(Texturize(aShape, "chataignier.gif"));
}
if (loadShape(aShape, "Kitchen\\MODERN_Exhaust_1.brep"))
{
moveScale(aShape);
DISP(drawShape(aShape, Graphic3d_NOM_STONE, Standard_False));
}
if (loadShape(aShape, "Kitchen\\MODERN_MVCooker_1.brep"))
{
moveScale(aShape);
DISP(drawShape(aShape, Graphic3d_NOM_SILVER, Standard_False));
}
if (loadShape(aShape, "Kitchen\\MODERN_MVCooker_1_opened.brep"))
{
moveScale(aShape);
DISP(drawShape(aShape, Graphic3d_NOM_SILVER, Standard_False));
}
if (loadShape(aShape, "Kitchen\\MODERN_Sink_1.brep"))
{
moveScale(aShape);
aFaces.Clear();
TopExp::MapShapes(aShape, TopAbs_FACE, aFaces);
nbFaces = aFaces.Extent();
for (Standard_Integer i = 1; i <= nbFaces; i++)
{
if (i < 145)
DISP(drawShape(aFaces(i), Graphic3d_NOM_ALUMINIUM, Standard_False));
else if (i == 145)
DISP(Texturize(aFaces(i), "cookerplate.gif"));
else
DISP(Texturize(aFaces(i), "chataignier.gif"));
}
}
if (loadShape(aShape, "Kitchen\\MODERN_Sink_1_opened.brep"))
{
moveScale(aShape);
DISP(Texturize(aShape, "chataignier.gif"));
}
if (loadShape(aShape, "Kitchen\\MODERN_Refrigerator_1.brep"))
{
moveScale(aShape);
DISP(drawShape(aShape, Graphic3d_NOM_CHROME, Standard_False));
}
if (loadShape(aShape, "Kitchen\\MODERN_Refrigerator_1_opened.brep"))
{
moveScale(aShape);
DISP(drawShape(aShape, Graphic3d_NOM_CHROME, Standard_False));
}
getViewer()->Update();
}
