1259 lines
39 KiB
C++
1259 lines
39 KiB
C++
/***************************************************************************
|
|
* Copyright (c) 2019 WandererFan <wandererfan@gmail.com> *
|
|
* *
|
|
* This file is part of the FreeCAD CAx development system. *
|
|
* *
|
|
* This library is free software; you can redistribute it and/or *
|
|
* modify it under the terms of the GNU Library General Public *
|
|
* License as published by the Free Software Foundation; either *
|
|
* version 2 of the License, or (at your option) any later version. *
|
|
* *
|
|
* 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 Library General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Library General Public *
|
|
* License along with this library; see the file COPYING.LIB. If not, *
|
|
* write to the Free Software Foundation, Inc., 59 Temple Place, *
|
|
* Suite 330, Boston, MA 02111-1307, USA *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
#include "PreCompiled.h"
|
|
#ifndef _PreComp_
|
|
#include <cmath>
|
|
#include <gp_Pnt.hxx>
|
|
#include <gp_Dir.hxx>
|
|
#include <gp_Ax1.hxx>
|
|
#include <gp_Circ.hxx>
|
|
#include <Geom_Circle.hxx>
|
|
#include <BRepBuilderAPI_MakeEdge.hxx>
|
|
#include <TopoDS.hxx>
|
|
#include <TopoDS_Shape.hxx>
|
|
#include <TopoDS_Edge.hxx>
|
|
#include <BRepBndLib.hxx>
|
|
#include <Bnd_Box.hxx>
|
|
#endif // #ifndef _PreComp_
|
|
|
|
#include <Base/Console.h>
|
|
#include <Base/Exception.h>
|
|
#include <Base/Parameter.h>
|
|
#include <Base/Reader.h>
|
|
#include <Base/Tools.h>
|
|
#include <Base/Vector3D.h>
|
|
#include <Base/Writer.h>
|
|
|
|
#include <App/Application.h>
|
|
#include <App/Material.h>
|
|
|
|
#include <Mod/TechDraw/App/GeomFormatPy.h>
|
|
#include <Mod/TechDraw/App/CenterLinePy.h>
|
|
#include <Mod/TechDraw/App/CosmeticEdgePy.h>
|
|
#include <Mod/TechDraw/App/CosmeticVertexPy.h>
|
|
|
|
#include "DrawUtil.h"
|
|
#include "GeometryObject.h"
|
|
#include "Geometry.h"
|
|
#include "DrawViewPart.h"
|
|
|
|
#include "Cosmetic.h"
|
|
|
|
using namespace TechDraw;
|
|
|
|
LineFormat::LineFormat()
|
|
{
|
|
m_style = getDefEdgeStyle();
|
|
m_weight = getDefEdgeWidth();
|
|
m_color = getDefEdgeColor();
|
|
m_visible = true;
|
|
}
|
|
|
|
LineFormat::LineFormat(int style,
|
|
double weight,
|
|
App::Color color,
|
|
bool visible ) :
|
|
m_style(style),
|
|
m_weight(weight),
|
|
m_color(color),
|
|
m_visible(visible)
|
|
{
|
|
}
|
|
|
|
void LineFormat::dump(char* title)
|
|
{
|
|
Base::Console().Message("LF::dump - %s \n",title);
|
|
Base::Console().Message("LF::dump - %s \n",toString().c_str());
|
|
}
|
|
|
|
std::string LineFormat::toString(void) const
|
|
{
|
|
std::stringstream ss;
|
|
ss << m_style << "," <<
|
|
m_weight << "," <<
|
|
m_color.asHexString() << "," <<
|
|
m_visible;
|
|
return ss.str();
|
|
}
|
|
|
|
//static preference getters.
|
|
double LineFormat::getDefEdgeWidth()
|
|
{
|
|
Base::Reference<ParameterGrp> hGrp = App::GetApplication().GetUserParameter().GetGroup("BaseApp")->
|
|
GetGroup("Preferences")->GetGroup("Mod/TechDraw/Decorations");
|
|
std::string lgName = hGrp->GetASCII("LineGroup","FC 0.70mm");
|
|
auto lg = TechDraw::LineGroup::lineGroupFactory(lgName);
|
|
|
|
double width = lg->getWeight("Graphic");
|
|
delete lg;
|
|
return width;
|
|
}
|
|
|
|
App::Color LineFormat::getDefEdgeColor()
|
|
{
|
|
Base::Reference<ParameterGrp> hGrp = App::GetApplication().GetUserParameter()
|
|
.GetGroup("BaseApp")->GetGroup("Preferences")->GetGroup("Mod/TechDraw/Colors");
|
|
App::Color fcColor;
|
|
fcColor.setPackedValue(hGrp->GetUnsigned("NormalColor", 0x00000000)); //black
|
|
return fcColor;
|
|
}
|
|
|
|
int LineFormat::getDefEdgeStyle()
|
|
{
|
|
Base::Reference<ParameterGrp> hGrp = App::GetApplication().GetUserParameter()
|
|
.GetGroup("BaseApp")->GetGroup("Preferences")->GetGroup("Mod/TechDraw/Decorations");
|
|
int style = hGrp->GetInt("CosmoCLStyle", 2); //dashed
|
|
return style;
|
|
}
|
|
|
|
//****************************************************************************************
|
|
|
|
TYPESYSTEM_SOURCE(TechDraw::CosmeticVertex, Base::Persistence)
|
|
|
|
CosmeticVertex::CosmeticVertex() : TechDraw::Vertex()
|
|
{
|
|
point(Base::Vector3d(0.0, 0.0, 0.0));
|
|
Base::Reference<ParameterGrp> hGrp = App::GetApplication().GetUserParameter().GetGroup("BaseApp")->
|
|
GetGroup("Preferences")->GetGroup("Mod/TechDraw/Decorations");
|
|
App::Color fcColor;
|
|
fcColor.setPackedValue(hGrp->GetUnsigned("VertexColor", 0x00000000));
|
|
|
|
linkGeom = -1;
|
|
color = fcColor;
|
|
size = 3.0;
|
|
style = 1;
|
|
visible = true;
|
|
}
|
|
|
|
CosmeticVertex::CosmeticVertex(const TechDraw::CosmeticVertex* cv) : TechDraw::Vertex(cv)
|
|
{
|
|
linkGeom = cv->linkGeom;
|
|
color = cv->color;
|
|
size = cv->size;
|
|
style = cv->style;
|
|
visible = cv->visible;
|
|
}
|
|
|
|
CosmeticVertex::CosmeticVertex(Base::Vector3d loc) : TechDraw::Vertex(loc)
|
|
{
|
|
Base::Reference<ParameterGrp> hGrp = App::GetApplication().GetUserParameter().GetGroup("BaseApp")->
|
|
GetGroup("Preferences")->GetGroup("Mod/TechDraw/Decorations");
|
|
App::Color fcColor;
|
|
fcColor.setPackedValue(hGrp->GetUnsigned("VertexColor", 0xff000000));
|
|
|
|
linkGeom = -1;
|
|
color = fcColor;
|
|
//TODO: size = hGrp->getFloat("VertexSize",30.0);
|
|
size = 30.0;
|
|
style = 1; //TODO: implement styled vertexes
|
|
visible = true;
|
|
}
|
|
|
|
std::string CosmeticVertex::toString(void) const
|
|
{
|
|
std::stringstream ss;
|
|
ss << point().x << "," <<
|
|
point().y << "," <<
|
|
point().z << "," <<
|
|
|
|
linkGeom << "," <<
|
|
color.asHexString() << "," <<
|
|
size << "," <<
|
|
style << "," <<
|
|
visible;
|
|
return ss.str();
|
|
}
|
|
|
|
// Persistence implementers
|
|
unsigned int CosmeticVertex::getMemSize (void) const
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
void CosmeticVertex::Save(Base::Writer &writer) const
|
|
{
|
|
TechDraw::Vertex::Save(writer);
|
|
writer.Stream() << writer.ind() << "<LinkGeom value=\"" << linkGeom << "\"/>" << endl;
|
|
writer.Stream() << writer.ind() << "<Color value=\"" << color.asHexString() << "\"/>" << endl;
|
|
writer.Stream() << writer.ind() << "<Size value=\"" << size << "\"/>" << endl;
|
|
writer.Stream() << writer.ind() << "<Style value=\"" << style << "\"/>" << endl;
|
|
const char v = visible?'1':'0';
|
|
writer.Stream() << writer.ind() << "<Visible value=\"" << v << "\"/>" << endl;
|
|
}
|
|
|
|
void CosmeticVertex::Restore(Base::XMLReader &reader)
|
|
{
|
|
TechDraw::Vertex::Restore(reader);
|
|
reader.readElement("LinkGeom");
|
|
linkGeom = reader.getAttributeAsInteger("value");
|
|
reader.readElement("Color");
|
|
std::string temp = reader.getAttribute("value");
|
|
color.fromHexString(temp);
|
|
reader.readElement("Size");
|
|
size = reader.getAttributeAsFloat("value");
|
|
reader.readElement("Style");
|
|
style = reader.getAttributeAsInteger("value");
|
|
reader.readElement("Visible");
|
|
visible = (int)reader.getAttributeAsInteger("value")==0?false:true;
|
|
}
|
|
|
|
CosmeticVertex* CosmeticVertex::copy(void) const
|
|
{
|
|
// Base::Console().Message("CV::copy()\n");
|
|
CosmeticVertex* newCV = new CosmeticVertex(this);
|
|
return newCV;
|
|
}
|
|
|
|
CosmeticVertex* CosmeticVertex::clone(void) const
|
|
{
|
|
// Base::Console().Message("CV::clone()\n");
|
|
CosmeticVertex* cpy = this->copy();
|
|
return cpy;
|
|
}
|
|
|
|
PyObject* CosmeticVertex::getPyObject(void)
|
|
{
|
|
return new CosmeticVertexPy(new CosmeticVertex(this->copy()));
|
|
}
|
|
|
|
void CosmeticVertex::dump(char* title)
|
|
{
|
|
Base::Console().Message("CV::dump - %s \n",title);
|
|
Base::Console().Message("CV::dump - %s \n",toString().c_str());
|
|
}
|
|
|
|
//******************************************
|
|
|
|
TYPESYSTEM_SOURCE(TechDraw::CosmeticEdge,Base::Persistence)
|
|
|
|
//note this ctor has no occEdge or first/last point for geometry!
|
|
CosmeticEdge::CosmeticEdge()
|
|
{
|
|
// Base::Console().Message("CE::CE()\n");
|
|
m_geometry = new TechDraw::BaseGeom();
|
|
initialize();
|
|
}
|
|
|
|
CosmeticEdge::CosmeticEdge(CosmeticEdge* ce)
|
|
{
|
|
// Base::Console().Message("CE::CE(ce)\n");
|
|
//if ce gets deleted later, this CE will have an invalid pointer to geometry!
|
|
//need to make our own copy of the geometry
|
|
TechDraw::BaseGeom* newGeom = ce->m_geometry->copy();
|
|
m_geometry = newGeom;
|
|
m_format = ce->m_format;
|
|
}
|
|
|
|
CosmeticEdge::CosmeticEdge(Base::Vector3d pt1, Base::Vector3d pt2)
|
|
{
|
|
// Base::Console().Message("CE::CE(p1,p2)\n");
|
|
Base::Vector3d p1 = DrawUtil::invertY(pt1);
|
|
Base::Vector3d p2 = DrawUtil::invertY(pt2);
|
|
gp_Pnt gp1(p1.x,p1.y,p1.z);
|
|
gp_Pnt gp2(p2.x,p2.y,p2.z);
|
|
TopoDS_Edge e = BRepBuilderAPI_MakeEdge(gp1, gp2);
|
|
m_geometry = TechDraw::BaseGeom::baseFactory(e);
|
|
initialize();
|
|
}
|
|
|
|
CosmeticEdge::CosmeticEdge(TopoDS_Edge e)
|
|
{
|
|
// Base::Console().Message("CE::CE(TopoDS_Edge)\n");
|
|
m_geometry = TechDraw::BaseGeom::baseFactory(e);
|
|
initialize();
|
|
}
|
|
|
|
CosmeticEdge::CosmeticEdge(TechDraw::BaseGeom* g)
|
|
{
|
|
// Base::Console().Message("CE::CE(bg)\n");
|
|
m_geometry = g;
|
|
initialize();
|
|
}
|
|
|
|
CosmeticEdge::~CosmeticEdge(void)
|
|
{
|
|
if (m_geometry != nullptr) {
|
|
delete m_geometry;
|
|
}
|
|
}
|
|
|
|
void CosmeticEdge::initialize(void)
|
|
{
|
|
m_geometry->classOfEdge = ecHARD;
|
|
m_geometry->visible = true;
|
|
m_geometry->cosmetic = true;
|
|
}
|
|
|
|
TechDraw::BaseGeom* CosmeticEdge::scaledGeometry(double scale)
|
|
{
|
|
TechDraw::BaseGeom* newGeom = nullptr;
|
|
TopoDS_Edge e = m_geometry->occEdge;
|
|
TopoDS_Shape s = TechDraw::scaleShape(e, scale);
|
|
TopoDS_Edge newEdge = TopoDS::Edge(s);
|
|
newGeom = TechDraw::BaseGeom::baseFactory(newEdge);
|
|
newGeom->classOfEdge = ecHARD;
|
|
newGeom->visible = true;
|
|
newGeom->cosmetic = true;
|
|
return newGeom;
|
|
}
|
|
|
|
std::string CosmeticEdge::toString(void) const
|
|
{
|
|
std::stringstream ss;
|
|
if (m_geometry != nullptr) {
|
|
ss << m_geometry->geomType <<
|
|
",$$$," <<
|
|
m_geometry->toString() <<
|
|
",$$$," <<
|
|
m_format.toString();
|
|
}
|
|
return ss.str();
|
|
}
|
|
|
|
void CosmeticEdge::dump(char* title)
|
|
{
|
|
Base::Console().Message("CE::dump - %s \n",title);
|
|
Base::Console().Message("CE::dump - %s \n",toString().c_str());
|
|
}
|
|
|
|
// Persistence implementers
|
|
unsigned int CosmeticEdge::getMemSize (void) const
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
void CosmeticEdge::Save(Base::Writer &writer) const
|
|
{
|
|
writer.Stream() << writer.ind() << "<Style value=\"" << m_format.m_style << "\"/>" << endl;
|
|
writer.Stream() << writer.ind() << "<Weight value=\"" << m_format.m_weight << "\"/>" << endl;
|
|
writer.Stream() << writer.ind() << "<Color value=\"" << m_format.m_color.asHexString() << "\"/>" << endl;
|
|
const char v = m_format.m_visible?'1':'0';
|
|
writer.Stream() << writer.ind() << "<Visible value=\"" << v << "\"/>" << endl;
|
|
|
|
writer.Stream() << writer.ind() << "<GeometryType value=\"" << m_geometry->geomType <<"\"/>" << endl;
|
|
if (m_geometry->geomType == TechDraw::GeomType::GENERIC) {
|
|
Generic* gen = static_cast<Generic*>(m_geometry);
|
|
gen->Save(writer);
|
|
} else if (m_geometry->geomType == TechDraw::GeomType::CIRCLE) {
|
|
TechDraw::Circle* circ = static_cast<TechDraw::Circle*>(m_geometry);
|
|
circ->Save(writer);
|
|
} else if (m_geometry->geomType == TechDraw::GeomType::ARCOFCIRCLE) {
|
|
TechDraw::AOC* aoc = static_cast<TechDraw::AOC*>(m_geometry);
|
|
aoc->Save(writer);
|
|
} else {
|
|
Base::Console().Message("CE::Save - unimplemented geomType: %d\n", m_geometry->geomType);
|
|
}
|
|
}
|
|
|
|
void CosmeticEdge::Restore(Base::XMLReader &reader)
|
|
{
|
|
reader.readElement("Style");
|
|
m_format.m_style = reader.getAttributeAsInteger("value");
|
|
reader.readElement("Weight");
|
|
m_format.m_weight = reader.getAttributeAsFloat("value");
|
|
reader.readElement("Color");
|
|
std::string temp = reader.getAttribute("value");
|
|
m_format.m_color.fromHexString(temp);
|
|
reader.readElement("Visible");
|
|
m_format.m_visible = (int)reader.getAttributeAsInteger("value")==0?false:true;
|
|
reader.readElement("GeometryType");
|
|
TechDraw::GeomType gType = (TechDraw::GeomType)reader.getAttributeAsInteger("value");
|
|
|
|
if (gType == TechDraw::GeomType::GENERIC) {
|
|
TechDraw::Generic* gen = new TechDraw::Generic();
|
|
gen->Restore(reader);
|
|
gen->occEdge = GeometryUtils::edgeFromGeneric(gen);
|
|
m_geometry = (TechDraw::BaseGeom*) gen;
|
|
|
|
} else if (gType == TechDraw::GeomType::CIRCLE) {
|
|
TechDraw::Circle* circ = new TechDraw::Circle();
|
|
circ->Restore(reader);
|
|
circ->occEdge = GeometryUtils::edgeFromCircle(circ);
|
|
m_geometry = (TechDraw::BaseGeom*) circ;
|
|
} else if (gType == TechDraw::GeomType::ARCOFCIRCLE) {
|
|
TechDraw::AOC* aoc = new TechDraw::AOC();
|
|
aoc->Restore(reader);
|
|
aoc->occEdge = GeometryUtils::edgeFromCircleArc(aoc);
|
|
m_geometry = (TechDraw::BaseGeom*) aoc;
|
|
} else {
|
|
Base::Console().Message("CE::Restore - unimplemented geomType: %d\n", gType);
|
|
}
|
|
}
|
|
|
|
CosmeticEdge* CosmeticEdge::copy(void) const
|
|
{
|
|
// Base::Console().Message("CE::copy()\n");
|
|
CosmeticEdge* newCE = new CosmeticEdge();
|
|
TechDraw::BaseGeom* newGeom = m_geometry->copy();
|
|
newCE->m_geometry = newGeom;
|
|
newCE->m_format = m_format;
|
|
return newCE;
|
|
}
|
|
|
|
CosmeticEdge* CosmeticEdge::clone(void) const
|
|
{
|
|
// Base::Console().Message("CE::clone()\n");
|
|
CosmeticEdge* cpy = this->copy();
|
|
return cpy;
|
|
}
|
|
|
|
PyObject* CosmeticEdge::getPyObject(void)
|
|
{
|
|
return new CosmeticEdgePy(new CosmeticEdge(this->copy()));
|
|
}
|
|
|
|
//*********************************************************
|
|
|
|
TYPESYSTEM_SOURCE(TechDraw::CenterLine,Base::Persistence)
|
|
|
|
CenterLine::CenterLine(void)
|
|
{
|
|
m_start = Base::Vector3d(0.0, 0.0, 0.0);
|
|
m_end = Base::Vector3d(0.0, 0.0, 0.0);
|
|
m_mode = CLMODE::VERTICAL;
|
|
m_hShift = 0.0;
|
|
m_vShift = 0.0;
|
|
m_rotate = 0.0;
|
|
m_extendBy = 0.0;
|
|
m_type = CLTYPE::FACE;
|
|
m_flip2Line = false;
|
|
|
|
}
|
|
|
|
CenterLine::CenterLine(CenterLine* cl)
|
|
{
|
|
m_start = cl->m_start;
|
|
m_end = cl->m_end;
|
|
m_mode = cl->m_mode;
|
|
m_hShift = cl->m_hShift;
|
|
m_vShift = cl->m_vShift;
|
|
m_rotate = cl->m_rotate;
|
|
m_extendBy = cl->m_extendBy;
|
|
m_faces = cl->m_faces;
|
|
m_format = cl->m_format;
|
|
m_type = cl->m_type;
|
|
m_flip2Line = cl->m_flip2Line;
|
|
m_edges = cl->m_edges;
|
|
m_verts = cl->m_verts;
|
|
}
|
|
|
|
CenterLine::CenterLine(Base::Vector3d p1, Base::Vector3d p2)
|
|
{
|
|
m_start = p1;
|
|
m_end = p2;
|
|
m_mode = CLMODE::VERTICAL;
|
|
m_hShift = 0.0;
|
|
m_vShift = 0.0;
|
|
m_rotate = 0.0;
|
|
m_extendBy = 0.0;
|
|
m_type = CLTYPE::FACE;
|
|
m_flip2Line = false;
|
|
}
|
|
|
|
CenterLine::CenterLine(Base::Vector3d p1, Base::Vector3d p2,
|
|
int m,
|
|
double h,
|
|
double v,
|
|
double r,
|
|
double x)
|
|
{
|
|
m_start = p1;
|
|
m_end = p2;
|
|
m_mode = m;
|
|
m_hShift = h;
|
|
m_vShift = v;
|
|
m_rotate = r;
|
|
m_extendBy = x;
|
|
m_type = CLTYPE::FACE;
|
|
m_flip2Line = false;
|
|
}
|
|
|
|
CenterLine::~CenterLine()
|
|
{
|
|
}
|
|
|
|
CenterLine* CenterLine::CenterLineBuilder(DrawViewPart* partFeat, std::vector<std::string> subNames, int mode)
|
|
{
|
|
// Base::Console().Message("CL::CLBuilder()\n");
|
|
std::pair<Base::Vector3d, Base::Vector3d> ends;
|
|
std::vector<std::string> faces;
|
|
std::vector<std::string> edges;
|
|
std::vector<std::string> verts;
|
|
|
|
std::string geomType = TechDraw::DrawUtil::getGeomTypeFromName(subNames.front());
|
|
int type = CLTYPE::FACE;
|
|
if (geomType == "Face") {
|
|
type = CLTYPE::FACE;
|
|
ends = TechDraw::CenterLine::calcEndPoints(partFeat,
|
|
subNames,
|
|
mode,
|
|
0.0,
|
|
0.0, 0.0, 0.0);
|
|
faces = subNames;
|
|
} else if (geomType == "Edge") {
|
|
type = CLTYPE::EDGE;
|
|
ends = TechDraw::CenterLine::calcEndPoints2Lines(partFeat,
|
|
subNames,
|
|
mode,
|
|
0.0,
|
|
0.0, 0.0, 0.0, false);
|
|
edges = subNames;
|
|
} else if (geomType == "Vertex") {
|
|
type = CLTYPE::VERTEX;
|
|
ends = TechDraw::CenterLine::calcEndPoints2Points(partFeat,
|
|
subNames,
|
|
mode,
|
|
0.0,
|
|
0.0, 0.0, 0.0, false);
|
|
verts = subNames;
|
|
}
|
|
TechDraw::CenterLine* cl = new TechDraw::CenterLine(ends.first, ends.second);
|
|
if (cl != nullptr) {
|
|
// cl->m_start = ends.first;
|
|
// cl->m_end = ends.second;
|
|
cl->m_type = type;
|
|
cl->m_mode = mode;
|
|
cl->m_faces = faces;
|
|
cl->m_edges = edges;
|
|
cl->m_verts = verts;
|
|
// cl->m_flip2Line = false;
|
|
}
|
|
return cl;
|
|
}
|
|
|
|
TechDraw::BaseGeom* CenterLine::scaledGeometry(TechDraw::DrawViewPart* partFeat)
|
|
{
|
|
// Base::Console().Message("CL::scaledGeometry() - m_type: %d\n", m_type);
|
|
double scale = partFeat->getScale();
|
|
if (m_faces.empty() &&
|
|
m_edges.empty() &&
|
|
m_verts.empty() ) {
|
|
Base::Console().Message("CL::scaledGeometry - no geometry to scale!\n");
|
|
return nullptr;
|
|
}
|
|
|
|
std::pair<Base::Vector3d, Base::Vector3d> ends;
|
|
if (m_type == CLTYPE::FACE) {
|
|
ends = calcEndPoints(partFeat,
|
|
m_faces,
|
|
m_mode, m_extendBy,
|
|
m_hShift,m_vShift, m_rotate);
|
|
} else if (m_type == CLTYPE::EDGE) {
|
|
ends = calcEndPoints2Lines(partFeat,
|
|
m_edges,
|
|
m_mode,
|
|
m_extendBy,
|
|
m_hShift, m_vShift, m_rotate, m_flip2Line);
|
|
} else if (m_type == CLTYPE::VERTEX) {
|
|
ends = calcEndPoints2Points(partFeat,
|
|
m_verts,
|
|
m_mode,
|
|
m_extendBy,
|
|
m_hShift, m_vShift, m_rotate, m_flip2Line);
|
|
}
|
|
|
|
TechDraw::BaseGeom* newGeom = nullptr;
|
|
Base::Vector3d p1 = ends.first;
|
|
Base::Vector3d p2 = ends.second;
|
|
gp_Pnt gp1(p1.x,p1.y,p1.z);
|
|
gp_Pnt gp2(p2.x,p2.y,p2.z);
|
|
TopoDS_Edge e = BRepBuilderAPI_MakeEdge(gp1, gp2);
|
|
TopoDS_Shape s = TechDraw::scaleShape(e, scale);
|
|
TopoDS_Edge newEdge = TopoDS::Edge(s);
|
|
newGeom = TechDraw::BaseGeom::baseFactory(newEdge);
|
|
newGeom->classOfEdge = ecHARD;
|
|
newGeom->visible = true;
|
|
newGeom->cosmetic = true;
|
|
return newGeom;
|
|
}
|
|
|
|
std::string CenterLine::toString(void) const
|
|
{
|
|
std::stringstream ss;
|
|
ss << m_start.x << "," <<
|
|
m_start.y << "," <<
|
|
m_start.z << "," <<
|
|
m_end.x << "," <<
|
|
m_end.y << "," <<
|
|
m_end.z << "," <<
|
|
m_mode << "," <<
|
|
m_type << "," <<
|
|
m_hShift << "," <<
|
|
m_vShift << "," <<
|
|
m_rotate << "," <<
|
|
m_flip2Line << "," <<
|
|
m_extendBy << "," <<
|
|
m_faces.size();
|
|
if (!m_faces.empty()) {
|
|
for (auto& f: m_faces) {
|
|
if (!f.empty()) {
|
|
ss << "," << f ;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string clCSV = ss.str();
|
|
std::string fmtCSV = m_format.toString();
|
|
return clCSV + ",$$$," + fmtCSV;
|
|
}
|
|
|
|
void CenterLine::dump(char* title)
|
|
{
|
|
Base::Console().Message("CL::dump - %s \n",title);
|
|
Base::Console().Message("CL::dump - %s \n",toString().c_str());
|
|
}
|
|
|
|
//end points for face centerline
|
|
std::pair<Base::Vector3d, Base::Vector3d> CenterLine::calcEndPoints(DrawViewPart* partFeat,
|
|
std::vector<std::string> faceNames,
|
|
int mode, double ext,
|
|
double hShift, double vShift,
|
|
double rotate)
|
|
{
|
|
std::pair<Base::Vector3d, Base::Vector3d> result;
|
|
if (faceNames.empty()) {
|
|
Base::Console().Message("CL::calcEndPoints - no faces!\n");
|
|
return result;
|
|
}
|
|
|
|
Bnd_Box faceBox;
|
|
faceBox.SetGap(0.0);
|
|
|
|
double scale = partFeat->getScale();
|
|
|
|
for (auto& fn: faceNames) {
|
|
if (TechDraw::DrawUtil::getGeomTypeFromName(fn) != "Face") {
|
|
continue;
|
|
}
|
|
int idx = TechDraw::DrawUtil::getIndexFromName(fn);
|
|
std::vector<TechDraw::BaseGeom*> faceEdges =
|
|
partFeat->getFaceEdgesByIndex(idx);
|
|
for (auto& fe: faceEdges) {
|
|
if (!fe->cosmetic) {
|
|
BRepBndLib::Add(fe->occEdge, faceBox);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (faceBox.IsVoid()) {
|
|
Base::Console().Error("CL::calcEndPoints - faceBox is void!\n");
|
|
return result;
|
|
}
|
|
|
|
double Xmin,Ymin,Zmin,Xmax,Ymax,Zmax;
|
|
faceBox.Get(Xmin,Ymin,Zmin,Xmax,Ymax,Zmax);
|
|
|
|
double Xspan = fabs(Xmax - Xmin);
|
|
Xspan = (Xspan / 2.0);
|
|
double Xmid = Xmin + Xspan;
|
|
|
|
double Yspan = fabs(Ymax - Ymin);
|
|
Yspan = (Yspan / 2.0);
|
|
double Ymid = Ymin + Yspan;
|
|
|
|
Base::Vector3d p1, p2;
|
|
if (mode == 0) { //vertical
|
|
p1 = Base::Vector3d(Xmid, Ymax, 0.0);
|
|
p2 = Base::Vector3d(Xmid, Ymin, 0.0);
|
|
} else if (mode == 1) { //horizontal
|
|
p1 = Base::Vector3d(Xmin, Ymid, 0.0);
|
|
p2 = Base::Vector3d(Xmax,Ymid, 0.0);
|
|
} else { //vert == 2 //aligned, but aligned doesn't make sense for face(s) bbox
|
|
Base::Console().Message("CL::calcEndPoints - aligned is not applicable to Face center lines\n");
|
|
p1 = Base::Vector3d(Xmid, Ymax, 0.0);
|
|
p2 = Base::Vector3d(Xmid, Ymin, 0.0);
|
|
}
|
|
|
|
Base::Vector3d mid = (p1 + p2) / 2.0;
|
|
|
|
//extend
|
|
Base::Vector3d clDir = p2 - p1;
|
|
clDir.Normalize();
|
|
p1 = p1 - (clDir * ext);
|
|
p2 = p2 + (clDir * ext);
|
|
|
|
//rotate
|
|
if (!DrawUtil::fpCompare(rotate, 0.0)) {
|
|
//rotate p1, p2 about mid point
|
|
double revRotate = -rotate;
|
|
double cosTheta = cos(revRotate * M_PI / 180.0);
|
|
double sinTheta = sin(revRotate * M_PI / 180.0);
|
|
Base::Vector3d toOrg = p1 - mid;
|
|
double xRot = toOrg.x * cosTheta - toOrg.y * sinTheta;
|
|
double yRot = toOrg.y * cosTheta + toOrg.x * sinTheta;
|
|
p1 = Base::Vector3d(xRot, yRot, 0.0) + mid;
|
|
toOrg = p2 - mid;
|
|
xRot = toOrg.x * cosTheta - toOrg.y * sinTheta;
|
|
yRot = toOrg.y * cosTheta + toOrg.x * sinTheta;
|
|
p2 = Base::Vector3d(xRot, yRot, 0.0) + mid;
|
|
}
|
|
|
|
//shift
|
|
if (!DrawUtil::fpCompare(hShift, 0.0)) {
|
|
double hss = hShift * scale;
|
|
p1.x = p1.x + hss;
|
|
p2.x = p2.x + hss;
|
|
}
|
|
if (!DrawUtil::fpCompare(vShift, 0.0)) {
|
|
double vss = vShift * scale;
|
|
p1.y = p1.y + vss;
|
|
p2.y = p2.y + vss;
|
|
}
|
|
|
|
result.first = p1 / scale;
|
|
result.second = p2 / scale;
|
|
return result;
|
|
}
|
|
|
|
std::pair<Base::Vector3d, Base::Vector3d> CenterLine::calcEndPoints2Lines(DrawViewPart* partFeat,
|
|
std::vector<std::string> edgeNames,
|
|
int mode, double ext,
|
|
double hShift, double vShift,
|
|
double rotate, bool flip)
|
|
|
|
{
|
|
// Base::Console().Message("CL::calc2Lines()\n");
|
|
std::pair<Base::Vector3d, Base::Vector3d> result;
|
|
if (edgeNames.empty()) {
|
|
Base::Console().Message("CL::calcEndPoints2Lines - no edges!\n");
|
|
return result;
|
|
}
|
|
|
|
double scale = partFeat->getScale();
|
|
|
|
std::vector<TechDraw::BaseGeom*> edges;
|
|
for (auto& en: edgeNames) {
|
|
if (TechDraw::DrawUtil::getGeomTypeFromName(en) != "Edge") {
|
|
continue;
|
|
}
|
|
int idx = TechDraw::DrawUtil::getIndexFromName(en);
|
|
TechDraw::BaseGeom* bg = partFeat->getGeomByIndex(idx);
|
|
edges.push_back(bg);
|
|
}
|
|
if (edges.size() != 2) {
|
|
Base::Console().Message("CL::calcEndPoints2Lines - wrong number of edges!\n");
|
|
return result;
|
|
}
|
|
|
|
Base::Vector3d l1p1 = edges.front()->getStartPoint();
|
|
Base::Vector3d l1p2 = edges.front()->getEndPoint();
|
|
Base::Vector3d l2p1 = edges.back()->getStartPoint();
|
|
Base::Vector3d l2p2 = edges.back()->getEndPoint();
|
|
|
|
if (flip) {
|
|
Base::Vector3d temp;
|
|
temp = l2p1;
|
|
l2p1 = l2p2;
|
|
l2p2 = temp;
|
|
}
|
|
Base::Vector3d p1 = (l1p1 + l2p1) / 2.0;
|
|
Base::Vector3d p2 = (l1p2 + l2p2) / 2.0;
|
|
Base::Vector3d mid = (p1 + p2) / 2.0;
|
|
|
|
if (mode == 0) { //Vertical
|
|
p1.x = mid.x;
|
|
p2.x = mid.x;
|
|
} else if (mode == 1) { //Horizontal
|
|
p1.y = mid.y;
|
|
p2.y = mid.y;
|
|
} else if (mode == 2) { //Aligned
|
|
// no op
|
|
}
|
|
|
|
//extend
|
|
Base::Vector3d clDir = p2 - p1;
|
|
clDir.Normalize();
|
|
p1 = p1 - (clDir * ext);
|
|
p2 = p2 + (clDir * ext);
|
|
|
|
//rotate
|
|
if (!DrawUtil::fpCompare(rotate, 0.0)) {
|
|
//rotate p1, p2 about mid
|
|
double revRotate = -rotate;
|
|
double cosTheta = cos(revRotate * M_PI / 180.0);
|
|
double sinTheta = sin(revRotate * M_PI / 180.0);
|
|
Base::Vector3d toOrg = p1 - mid;
|
|
double xRot = toOrg.x * cosTheta - toOrg.y * sinTheta;
|
|
double yRot = toOrg.y * cosTheta + toOrg.x * sinTheta;
|
|
p1 = Base::Vector3d(xRot, yRot, 0.0) + mid;
|
|
toOrg = p2 - mid;
|
|
xRot = toOrg.x * cosTheta - toOrg.y * sinTheta;
|
|
yRot = toOrg.y * cosTheta + toOrg.x * sinTheta;
|
|
p2 = Base::Vector3d(xRot, yRot, 0.0) + mid;
|
|
}
|
|
|
|
//shift
|
|
if (!DrawUtil::fpCompare(hShift, 0.0)) {
|
|
double hss = hShift * scale;
|
|
p1.x = p1.x + hss;
|
|
p2.x = p2.x + hss;
|
|
}
|
|
if (!DrawUtil::fpCompare(vShift, 0.0)) {
|
|
double vss = vShift * scale;
|
|
p1.y = p1.y + vss;
|
|
p2.y = p2.y + vss;
|
|
}
|
|
|
|
result.first = p1 / scale;
|
|
result.second = p2 / scale;
|
|
return result;
|
|
}
|
|
|
|
std::pair<Base::Vector3d, Base::Vector3d> CenterLine::calcEndPoints2Points(DrawViewPart* partFeat,
|
|
std::vector<std::string> vertNames,
|
|
int mode, double ext,
|
|
double hShift, double vShift,
|
|
double rotate, bool flip)
|
|
|
|
{
|
|
// Base::Console().Message("CL::calc2Points()\n");
|
|
std::pair<Base::Vector3d, Base::Vector3d> result;
|
|
if (vertNames.empty()) {
|
|
Base::Console().Message("CL::calcEndPoints2Points - no points!\n");
|
|
return result;
|
|
}
|
|
|
|
double scale = partFeat->getScale();
|
|
|
|
std::vector<TechDraw::Vertex*> points;
|
|
for (auto& vn: vertNames) {
|
|
if (TechDraw::DrawUtil::getGeomTypeFromName(vn) != "Vertex") {
|
|
continue;
|
|
}
|
|
int idx = TechDraw::DrawUtil::getIndexFromName(vn);
|
|
TechDraw::Vertex* v = partFeat->getProjVertexByIndex(idx);
|
|
points.push_back(v);
|
|
}
|
|
if (points.size() != 2) {
|
|
Base::Console().Message("CL::calcEndPoints2Points - wrong number of points!\n");
|
|
return result;
|
|
}
|
|
|
|
Base::Vector3d v1 = points.front()->point();
|
|
Base::Vector3d v2 = points.back()->point();
|
|
|
|
Base::Vector3d mid = (v1 + v2) / 2.0;
|
|
Base::Vector3d dir = v2 - v1;
|
|
double length = dir.Length();
|
|
dir.Normalize();
|
|
Base::Vector3d clDir(dir.y, -dir.x, dir.z);
|
|
|
|
Base::Vector3d p1 = mid + clDir * (length / 2.0);
|
|
Base::Vector3d p2 = mid - clDir * (length / 2.0);
|
|
|
|
if (flip) {
|
|
Base::Vector3d temp;
|
|
temp = p1;
|
|
p1 = p2;
|
|
p2 = temp;
|
|
}
|
|
|
|
if (mode == 0) { //Vertical
|
|
p1.x = mid.x;
|
|
p2.x = mid.x;
|
|
} else if (mode == 1) { //Horizontal
|
|
p1.y = mid.y;
|
|
p2.y = mid.y;
|
|
} else if (mode == 2) { //Aligned
|
|
// no op
|
|
}
|
|
|
|
|
|
//extend
|
|
p1 = p1 - (clDir * ext);
|
|
p2 = p2 + (clDir * ext);
|
|
|
|
//rotate
|
|
if (!DrawUtil::fpCompare(rotate, 0.0)) {
|
|
//rotate p1, p2 about mid
|
|
double revRotate = -rotate;
|
|
double cosTheta = cos(revRotate * M_PI / 180.0);
|
|
double sinTheta = sin(revRotate * M_PI / 180.0);
|
|
Base::Vector3d toOrg = p1 - mid;
|
|
double xRot = toOrg.x * cosTheta - toOrg.y * sinTheta;
|
|
double yRot = toOrg.y * cosTheta + toOrg.x * sinTheta;
|
|
p1 = Base::Vector3d(xRot, yRot, 0.0) + mid;
|
|
toOrg = p2 - mid;
|
|
xRot = toOrg.x * cosTheta - toOrg.y * sinTheta;
|
|
yRot = toOrg.y * cosTheta + toOrg.x * sinTheta;
|
|
p2 = Base::Vector3d(xRot, yRot, 0.0) + mid;
|
|
}
|
|
|
|
//shift
|
|
if (!DrawUtil::fpCompare(hShift, 0.0)) {
|
|
double hss = hShift * scale;
|
|
p1.x = p1.x + hss;
|
|
p2.x = p2.x + hss;
|
|
}
|
|
if (!DrawUtil::fpCompare(vShift, 0.0)) {
|
|
double vss = vShift * scale;
|
|
p1.y = p1.y + vss;
|
|
p2.y = p2.y + vss;
|
|
}
|
|
|
|
result.first = p1 / scale;
|
|
result.second = p2 / scale;
|
|
return result;
|
|
}
|
|
|
|
// Persistence implementers
|
|
unsigned int CenterLine::getMemSize (void) const
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
void CenterLine::Save(Base::Writer &writer) const
|
|
{
|
|
writer.Stream() << writer.ind() << "<Start "
|
|
<< "X=\"" << m_start.x <<
|
|
"\" Y=\"" << m_start.y <<
|
|
"\" Z=\"" << m_start.z <<
|
|
"\"/>" << endl;
|
|
writer.Stream() << writer.ind() << "<End "
|
|
<< "X=\"" << m_end.x <<
|
|
"\" Y=\"" << m_end.y <<
|
|
"\" Z=\"" << m_end.z <<
|
|
"\"/>" << endl;
|
|
writer.Stream() << writer.ind() << "<Mode value=\"" << m_mode <<"\"/>" << endl;
|
|
writer.Stream() << writer.ind() << "<HShift value=\"" << m_hShift <<"\"/>" << endl;
|
|
writer.Stream() << writer.ind() << "<VShift value=\"" << m_vShift <<"\"/>" << endl;
|
|
writer.Stream() << writer.ind() << "<Rotate value=\"" << m_rotate <<"\"/>" << endl;
|
|
writer.Stream() << writer.ind() << "<Extend value=\"" << m_extendBy <<"\"/>" << endl;
|
|
writer.Stream() << writer.ind() << "<Type value=\"" << m_type <<"\"/>" << endl;
|
|
writer.Stream() << writer.ind() << "<Flip value=\"" << m_flip2Line <<"\"/>" << endl;
|
|
writer.Stream()
|
|
<< writer.ind()
|
|
<< "<Faces "
|
|
<< "FaceCount=\"" << m_faces.size() <<
|
|
"\">" << endl;
|
|
|
|
writer.incInd();
|
|
for (auto& f: m_faces) {
|
|
writer.Stream()
|
|
<< writer.ind()
|
|
<< "<Face value=\"" << f <<"\"/>" << endl;
|
|
}
|
|
writer.decInd();
|
|
|
|
writer.Stream() << writer.ind() << "</Faces>" << endl ;
|
|
|
|
writer.Stream()
|
|
<< writer.ind()
|
|
<< "<Edges "
|
|
<< "EdgeCount=\"" << m_edges.size() <<
|
|
"\">" << endl;
|
|
|
|
writer.incInd();
|
|
for (auto& e: m_edges) {
|
|
writer.Stream()
|
|
<< writer.ind()
|
|
<< "<Edge value=\"" << e <<"\"/>" << endl;
|
|
}
|
|
writer.decInd();
|
|
writer.Stream() << writer.ind() << "</Edges>" << endl ;
|
|
|
|
writer.Stream()
|
|
<< writer.ind()
|
|
<< "<Points "
|
|
<< "PointCount=\"" << m_verts.size() <<
|
|
"\">" << endl;
|
|
|
|
writer.incInd();
|
|
for (auto& p: m_verts) {
|
|
writer.Stream()
|
|
<< writer.ind()
|
|
<< "<Point value=\"" << p <<"\"/>" << endl;
|
|
}
|
|
writer.decInd();
|
|
writer.Stream() << writer.ind() << "</Points>" << endl ;
|
|
|
|
writer.Stream() << writer.ind() << "<Style value=\"" << m_format.m_style << "\"/>" << endl;
|
|
writer.Stream() << writer.ind() << "<Weight value=\"" << m_format.m_weight << "\"/>" << endl;
|
|
writer.Stream() << writer.ind() << "<Color value=\"" << m_format.m_color.asHexString() << "\"/>" << endl;
|
|
const char v = m_format.m_visible?'1':'0';
|
|
writer.Stream() << writer.ind() << "<Visible value=\"" << v << "\"/>" << endl;
|
|
}
|
|
|
|
void CenterLine::Restore(Base::XMLReader &reader)
|
|
{
|
|
// read my Element
|
|
reader.readElement("Start");
|
|
// get the value of my Attribute
|
|
m_start.x = reader.getAttributeAsFloat("X");
|
|
m_start.y = reader.getAttributeAsFloat("Y");
|
|
m_start.z = reader.getAttributeAsFloat("Z");
|
|
|
|
reader.readElement("End");
|
|
m_end.x = reader.getAttributeAsFloat("X");
|
|
m_end.y = reader.getAttributeAsFloat("Y");
|
|
m_end.z = reader.getAttributeAsFloat("Z");
|
|
|
|
reader.readElement("Mode");
|
|
m_mode = reader.getAttributeAsInteger("value");
|
|
|
|
reader.readElement("HShift");
|
|
m_hShift = reader.getAttributeAsFloat("value");
|
|
reader.readElement("VShift");
|
|
m_vShift = reader.getAttributeAsFloat("value");
|
|
reader.readElement("Rotate");
|
|
m_rotate = reader.getAttributeAsFloat("value");
|
|
reader.readElement("Extend");
|
|
m_extendBy = reader.getAttributeAsFloat("value");
|
|
reader.readElement("Type");
|
|
m_type = reader.getAttributeAsInteger("value");
|
|
reader.readElement("Flip");
|
|
m_flip2Line = (bool)reader.getAttributeAsInteger("value")==0?false:true;
|
|
|
|
reader.readElement("Faces");
|
|
int count = reader.getAttributeAsInteger("FaceCount");
|
|
|
|
int i = 0;
|
|
for ( ; i < count; i++) {
|
|
reader.readElement("Face");
|
|
std::string f = reader.getAttribute("value");
|
|
m_faces.push_back(f);
|
|
}
|
|
reader.readEndElement("Faces");
|
|
|
|
reader.readElement("Edges");
|
|
count = reader.getAttributeAsInteger("EdgeCount");
|
|
|
|
i = 0;
|
|
for ( ; i < count; i++) {
|
|
reader.readElement("Edge");
|
|
std::string e = reader.getAttribute("value");
|
|
m_edges.push_back(e);
|
|
}
|
|
reader.readEndElement("Edges");
|
|
|
|
reader.readElement("Points");
|
|
count = reader.getAttributeAsInteger("PointCount");
|
|
|
|
i = 0;
|
|
for ( ; i < count; i++) {
|
|
reader.readElement("Point");
|
|
std::string p = reader.getAttribute("value");
|
|
m_verts.push_back(p);
|
|
}
|
|
reader.readEndElement("Points");
|
|
|
|
reader.readElement("Style");
|
|
m_format.m_style = reader.getAttributeAsInteger("value");
|
|
reader.readElement("Weight");
|
|
m_format.m_weight = reader.getAttributeAsFloat("value");
|
|
reader.readElement("Color");
|
|
std::string temp = reader.getAttribute("value");
|
|
m_format.m_color.fromHexString(temp);
|
|
reader.readElement("Visible");
|
|
m_format.m_visible = (int)reader.getAttributeAsInteger("value")==0?false:true;
|
|
}
|
|
|
|
CenterLine* CenterLine::copy(void) const
|
|
{
|
|
CenterLine* newCL = new CenterLine();
|
|
newCL->m_start = m_start;
|
|
newCL->m_end = m_end;
|
|
newCL->m_mode = m_mode;
|
|
newCL->m_hShift = m_hShift;
|
|
newCL->m_vShift = m_vShift;
|
|
newCL->m_rotate = m_rotate;
|
|
newCL->m_extendBy = m_extendBy;
|
|
newCL->m_type = m_type;
|
|
newCL->m_flip2Line = m_flip2Line;
|
|
|
|
newCL->m_faces = m_faces;
|
|
newCL->m_edges = m_edges;
|
|
newCL->m_verts = m_verts;
|
|
|
|
newCL->m_format.m_style = m_format.m_style;
|
|
newCL->m_format.m_weight = m_format.m_weight;
|
|
newCL->m_format.m_color = m_format.m_color;
|
|
newCL->m_format.m_visible = m_format.m_visible;
|
|
return newCL;
|
|
}
|
|
|
|
CenterLine* CenterLine::clone(void) const
|
|
{
|
|
CenterLine* cpy = this->copy();
|
|
return cpy;
|
|
}
|
|
|
|
PyObject* CenterLine::getPyObject(void)
|
|
{
|
|
return new CenterLinePy(new CenterLine(this->copy()));
|
|
}
|
|
|
|
void CenterLine::setShifts(double h, double v)
|
|
{
|
|
m_hShift = h;
|
|
m_vShift = v;
|
|
}
|
|
|
|
double CenterLine::getHShift(void)
|
|
{
|
|
return m_hShift;
|
|
}
|
|
|
|
double CenterLine::getVShift(void)
|
|
{
|
|
return m_vShift;
|
|
}
|
|
|
|
void CenterLine::setRotate(double r)
|
|
{
|
|
m_rotate = r;
|
|
}
|
|
|
|
double CenterLine::getRotate(void)
|
|
{
|
|
return m_rotate;
|
|
}
|
|
|
|
void CenterLine::setExtend(double e)
|
|
{
|
|
m_extendBy = e;
|
|
}
|
|
|
|
double CenterLine::getExtend(void)
|
|
{
|
|
return m_extendBy;
|
|
}
|
|
|
|
void CenterLine::setFlip(bool f)
|
|
{
|
|
m_flip2Line = f;
|
|
}
|
|
|
|
bool CenterLine::getFlip(void)
|
|
{
|
|
return m_flip2Line;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
TYPESYSTEM_SOURCE(TechDraw::GeomFormat,Base::Persistence)
|
|
|
|
GeomFormat::GeomFormat() :
|
|
m_geomIndex(-1)
|
|
{
|
|
m_format.m_style = LineFormat::getDefEdgeStyle();
|
|
m_format.m_weight = LineFormat::getDefEdgeWidth();
|
|
m_format.m_color = LineFormat::getDefEdgeColor();
|
|
m_format.m_visible = true;
|
|
}
|
|
|
|
GeomFormat::GeomFormat(GeomFormat* gf)
|
|
{
|
|
m_geomIndex = gf->m_geomIndex;
|
|
m_format.m_style = gf->m_format.m_style;
|
|
m_format.m_weight = gf->m_format.m_weight;
|
|
m_format.m_color = gf->m_format.m_color;
|
|
m_format.m_visible = gf->m_format.m_visible;
|
|
}
|
|
|
|
GeomFormat::GeomFormat(int idx,
|
|
TechDraw::LineFormat fmt) :
|
|
m_geomIndex(idx)
|
|
{
|
|
m_format.m_style = fmt.m_style;
|
|
m_format.m_weight = fmt.m_weight;
|
|
m_format.m_color = fmt.m_color;
|
|
m_format.m_visible = fmt.m_visible;
|
|
|
|
}
|
|
|
|
GeomFormat::~GeomFormat()
|
|
{
|
|
}
|
|
|
|
void GeomFormat::dump(char* title) const
|
|
{
|
|
Base::Console().Message("GF::dump - %s \n",title);
|
|
Base::Console().Message("GF::dump - %s \n",toString().c_str());
|
|
}
|
|
|
|
std::string GeomFormat::toString(void) const
|
|
{
|
|
std::stringstream ss;
|
|
ss << m_geomIndex << ",$$$," <<
|
|
m_format.toString();
|
|
return ss.str();
|
|
}
|
|
|
|
// Persistence implementer
|
|
unsigned int GeomFormat::getMemSize (void) const
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
void GeomFormat::Save(Base::Writer &writer) const
|
|
{
|
|
const char v = m_format.m_visible?'1':'0';
|
|
writer.Stream() << writer.ind() << "<GeomIndex value=\"" << m_geomIndex << "\"/>" << endl;
|
|
writer.Stream() << writer.ind() << "<Style value=\"" << m_format.m_style << "\"/>" << endl;
|
|
writer.Stream() << writer.ind() << "<Weight value=\"" << m_format.m_weight << "\"/>" << endl;
|
|
writer.Stream() << writer.ind() << "<Color value=\"" << m_format.m_color.asHexString() << "\"/>" << endl;
|
|
writer.Stream() << writer.ind() << "<Visible value=\"" << v << "\"/>" << endl;
|
|
}
|
|
|
|
void GeomFormat::Restore(Base::XMLReader &reader)
|
|
{
|
|
// read my Element
|
|
reader.readElement("GeomIndex");
|
|
// get the value of my Attribute
|
|
m_geomIndex = reader.getAttributeAsInteger("value");
|
|
|
|
reader.readElement("Style");
|
|
m_format.m_style = reader.getAttributeAsInteger("value");
|
|
reader.readElement("Weight");
|
|
m_format.m_weight = reader.getAttributeAsFloat("value");
|
|
reader.readElement("Color");
|
|
std::string temp = reader.getAttribute("value");
|
|
m_format.m_color.fromHexString(temp);
|
|
reader.readElement("Visible");
|
|
m_format.m_visible = (int)reader.getAttributeAsInteger("value")==0?false:true;
|
|
}
|
|
|
|
GeomFormat* GeomFormat::copy(void) const
|
|
{
|
|
GeomFormat* newFmt = new GeomFormat();
|
|
newFmt->m_geomIndex = m_geomIndex;
|
|
newFmt->m_format.m_style = m_format.m_style;
|
|
newFmt->m_format.m_weight = m_format.m_weight;
|
|
newFmt->m_format.m_color = m_format.m_color;
|
|
newFmt->m_format.m_visible = m_format.m_visible;
|
|
return newFmt;
|
|
}
|
|
|
|
GeomFormat* GeomFormat::clone(void) const
|
|
{
|
|
GeomFormat* cpy = this->copy();
|
|
return cpy;
|
|
}
|
|
|
|
PyObject* GeomFormat::getPyObject(void)
|
|
{
|
|
return new GeomFormatPy(new GeomFormat(this->copy()));
|
|
}
|
|
|
|
|