panda
/
COMPASSi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
COMPASSi/trunk/code/projects/OCC/OCCModeling/OffsetGenerate1.cpp

2447 lines
61 KiB
C++
Raw Normal View History

first commit
2025-06-25 15:06:42 +08:00
#include <math.h>
#include "OffsetGenerate1.h"
#include "OCCStructDataMD.h"
//#include "OCCViewer.h"
#include "OCCLib.h"
#include "BRepAlgoAPI_Section.hxx"
#include "BaseAlgo.h"
#include "Bnd_Box.hxx"
#include "BRepBndLib.hxx"
#include "BRepBuilderAPI_MakeFace.hxx"
#include "GC_MakePlane.hxx"
#include "BRepExtrema_DistShapeShape.hxx"
#include "BRepAlgoAPI_Common.hxx"
#include "Quantity_Color.hxx"
#include "Prs3d_PointAspect.hxx"
#include "Aspect_TypeOfMarker.hxx"
extern OCCStructDataMD dataMD;
//extern OCCViewer myOCCViewer;
OffsetGenerate1::OffsetGenerate1(void)
{
SecBottom = 1; //剖面底线
Base = 2; //基线
Water = 3; //水线
MainDeck = 4; //主甲板
UpperDeck = 5;//上甲板
FoldLine = 6; //折角线 ，
ProfileLine = 7; //纵剖线，
}
OffsetGenerate1::~OffsetGenerate1(void)
{}
int OffsetGenerate1::GetOffsetTableData(int upperDeckID, int foldingLinesID[], int isBilge, double BilgeHC, int shiptype, int asymmetricType,
int ids[], int lens[], OffsetTablePoint *pnts)
{
UpperDeckID =upperDeckID ; //上甲板ID
isBilge = isBilge;
BilgeHC = BilgeHC;
ShipType = shiptype;
AsymmetricType=asymmetricType;
try
{
//CalProfile();
//CalAngularL(foldingLinesID);
//CalUpperDeck();
GetHalfShell();
CalMainDeck();
CalSecLine();
CalBaseLine();
CalWaterLine();
map<int,vector<gp_Pnt>>::iterator it;
it=OPoints.begin();
int i = 0;
int j=0;
int cnt=0;
while(it!=OPoints.end()){
ids[i] = it->first;
for (j=0;j<it->second.size();j++)
{
pnts[cnt+j].X= it->second[j].X();
pnts[cnt+j].Y = it->second[j].Y();
pnts[cnt+j].Z = it->second[j].Z();
////
//if(ids[i] > 10000000 && ids[i] < 20000000)//最低点
//{
// TopoDS_Vertex v = BRepBuilderAPI_MakeVertex(it->second[j]);
// AnyCore::ASceneNodePtr aisShape=myOCCViewer.TopoShapeToASceneNode(v);//2016srq
// Quantity_Color color(Quantity_NOC_RED);
// Handle_Prs3d_PointAspect myPointAspect=new Prs3d_PointAspect(Aspect_TOM_O,color,2);
// aisShape->Attributes()->SetPointAspect(myPointAspect);
// myOCCViewer.ShowSceneNode(aisShape,false);//2016srq
//
//}
//if(ids[i] > 20000000 && ids[i] < 30000000)//基线
//{
// TopoDS_Vertex v = BRepBuilderAPI_MakeVertex(it->second[j]);
// AnyCore::ASceneNodePtr aisShape=myOCCViewer.TopoShapeToASceneNode(v);//2016srq
// Quantity_Color color(Quantity_NOC_RED);
// Handle_Prs3d_PointAspect myPointAspect=new Prs3d_PointAspect(Aspect_TOM_X,color,2);
// aisShape->Attributes()->SetPointAspect(myPointAspect);
// myOCCViewer.ShowSceneNode(aisShape,false);//2016srq
//}
//if(ids[i] > 30000000 && ids[i] < 40000000)//水线
//{
// TopoDS_Vertex v = BRepBuilderAPI_MakeVertex(it->second[j]);
// AnyCore::ASceneNodePtr aisShape=myOCCViewer.TopoShapeToASceneNode(v);//2016srq
// Quantity_Color color(Quantity_NOC_RED);
// Handle_Prs3d_PointAspect myPointAspect=new Prs3d_PointAspect(Aspect_TOM_BALL,color,2);
// aisShape->Attributes()->SetPointAspect(myPointAspect);
// myOCCViewer.ShowSceneNode(aisShape,false);//2016srq
//}
//if(ids[i] > 40000000 && ids[i] < 50000000)//甲板甲板
//{
// TopoDS_Vertex v = BRepBuilderAPI_MakeVertex(it->second[j]);
// AnyCore::ASceneNodePtr aisShape=myOCCViewer.TopoShapeToASceneNode(v);//2016srq
// Quantity_Color color(Quantity_NOC_RED);
//Handle_Prs3d_PointAspect myPointAspect=new Prs3d_PointAspect(Aspect_TOM_O_PLUS,color,2);
// aisShape->Attributes()->SetPointAspect(myPointAspect);
// myOCCViewer.ShowSceneNode(aisShape,false);//2016srq
//}
}
cnt = cnt+j;
lens[i] = j;
i++;
it++;
}
return i;
}
catch(Standard_Failure)
{
return 0;
}
}
//////////////////////////////////////////////////////////////////////////
//纵剖面线型值
void OffsetGenerate1::CalProfile()
{
int iIndex ;
map<int,double>::iterator it;
it=dataMD.m_mapButtocklinePos.begin();
int i = 0;
while(it!=dataMD.m_mapButtocklinePos.end()){
//根据给出的纵剖面线，然后每站求交点
vector<Handle(Geom_Curve)> curvesL;
vector<Handle(Geom_Curve)> curvesR;
vector<gp_Pnt> psL;
vector<gp_Pnt> psR;
ExtracteLine(-2,it->second,curvesL,curvesR,psL,psR);
if (curvesL.size() > 0){
double dl,df;
dl = curvesL[0]->FirstParameter();
df = curvesL[0]->LastParameter();
vector<gp_Pnt> ps = CalPoints(curvesL[0],dl,df);
if (((ShipType == 2) && (AsymmetricType == -1)) || (ShipType == 1) || (ShipType == 4))
{
if (it->second < 0)
{
iIndex = ProfileLine*11000+it->first;
OPoints.insert(pair<int,vector<gp_Pnt>>(iIndex,ps));
}else
{
iIndex = ProfileLine*10000+it->first;
OPoints.insert(pair<int,vector<gp_Pnt>>(iIndex,ps));
}
}else
{
if (it->second > 0)
{
iIndex = ProfileLine*11000+it->first;
OPoints.insert(pair<int,vector<gp_Pnt>>(iIndex,ps));
}else
{
iIndex = ProfileLine*10000+it->first;
OPoints.insert(pair<int,vector<gp_Pnt>>(iIndex,ps));
}
}
///
if (it->second < 0.0001)
CurProfile0 = curvesL[0];
///
}
i++;
++it;
}
//map<string,double> mProfilePos; //纵剖线位置
}
////////////////////////////////////////////////
//折角线半宽和高度 ，根据给出的折角线，然后每站求交点
//注意：折角线的高度不应超过甲板线（上甲板，无上甲板是主甲板），若超出，则填-1
void OffsetGenerate1::CalAngularL(int foldingLinesID[])
{
int iIndex;
for(int i=0;i<MAX_ARRAY_SIZE_L;i++)
{
if(foldingLinesID[i]>1)
{
//根据给出的折角线，然后每站求交点
vector<gp_Pnt> ps = CalPoints(foldingLinesID[i]);
if (((ShipType == 2) && (AsymmetricType == -1)) || (ShipType == 1)|| (ShipType == 4))
{
if (ps[0].Y() > 0)
{
iIndex = FoldLine *1000000+i;
OPoints.insert(pair<int,vector<gp_Pnt>>(iIndex,ps)); //去掉首尾
}else
{
iIndex = FoldLine *1100000+i;
OPoints.insert(pair<int,vector<gp_Pnt>>(iIndex,ps)); //去掉首尾
}
}else
{
if (ps[0].Y() < 0)
{
iIndex = FoldLine *1000000+i;
OPoints.insert(pair<int,vector<gp_Pnt>>(iIndex,ps)); //去掉首尾
}else
{
iIndex = FoldLine *1100000+i;
OPoints.insert(pair<int,vector<gp_Pnt>>(iIndex,ps)); //去掉首尾
}
}
}else
{
break;
}
}
}
////////////////////////////////////////////////
//上甲板半宽和高度 ，需要制定上甲板面，找出此面和船壳的交线，然后每站求交点
void OffsetGenerate1::CalUpperDeck()
{
}
////////////////////////////////////////////////
//主甲板半宽和高度 ，需要制定主甲板面/上甲板面，找出此面和船壳的交线，然后每站求交点
//SurfID 上甲板或者主甲板ID，FlagID 上甲板或者主甲板的标识
void OffsetGenerate1::CalMainDeck()
{
TopoDS_Shape mainDeck;
if(dataMD.m_mapMainDeckSurf.size()==1)
mainDeck=dataMD.m_mapAllTopoShapes.find(dataMD.m_mapMainDeckSurf.begin()->first)->second;
else
return;
vector<TopoDS_Edge> edges = GetShellSectionEdges(mainDeck);
Bnd_Box box;
double x1,x2,y1,y2,z1,z2;
for(vector<TopoDS_Edge>::iterator iter = edges.begin(); iter != edges.end(); iter++)
{
TopoDS_Edge edge = TopoDS::Edge(*iter);
BRepBndLib::Add(edge, box);
}
box.SetGap(0.0);
box.Get(x1,y1,z1,x2,y2,z2);
//艏端点
vector<gp_Pnt> pSetF;
TopoDS_Face ff = CreateFace(-1, x2);
for(vector<TopoDS_Edge>::iterator iter = edges.begin(); iter != edges.end(); iter++)
{
TopoDS_Edge edge = TopoDS::Edge(*iter);
vector<gp_Pnt> pSetFTmp = GetSectionPoints1(edge, ff);
//pSetFTmp = CleanPoints(pSetFTmp, -1, x1);
pSetF = AddPoints(pSetF, pSetFTmp);
}
pSetF = GetExtremePoints(pSetF, 1);
OPoints.insert(make_pair(40001000,pSetF));
//艉端点
vector<gp_Pnt> pSetD;
TopoDS_Face fd = CreateFace(-1, x1);
for(vector<TopoDS_Edge>::iterator iter = edges.begin(); iter != edges.end(); iter++)
{
TopoDS_Edge edge = TopoDS::Edge(*iter);
vector<gp_Pnt> pSetDTmp = GetSectionPoints1(edge, fd);
//pSetDTmp = CleanPoints(pSetDTmp, -1, x2);
pSetD = AddPoints(pSetD, pSetDTmp);
}
pSetD = GetExtremePoints(pSetD, -1);
OPoints.insert(make_pair(40003000,pSetD));
//站
for(int i = 0; i < dataMD.m_mapStation.size(); i++)
{
double x = dataMD.m_mapStation[i];
vector<gp_Pnt> pSet;
TopoDS_Face f = CreateFace(-1, x);
for(vector<TopoDS_Edge>::iterator iter = edges.begin(); iter != edges.end(); iter++)
{
TopoDS_Edge edge = TopoDS::Edge(*iter);
vector<gp_Pnt> pSetTmp = GetSectionPoints(edge, f);
pSetTmp = CleanPoints(pSetTmp, -1, x);
pSet = AddPoints(pSet, pSetTmp);
}
OPoints.insert(make_pair(40002000+i,pSet));
}
}
//SurfID 上甲板或者主甲板ID，FlagID 上甲板或者主甲板的标识
void OffsetGenerate1::CalDeck()
{
int i = 0;
vector<Handle(Geom_Curve)> curvesL;
vector<Handle(Geom_Curve)> curvesR;
vector<gp_Pnt> psL;
vector<gp_Pnt> psR;
vector<gp_Pnt> ListPnt;
vector<gp_Pnt> ListPnta;
gp_Pnt ptend;
//取得两端点坐标
if (dataMD.m_mapMainDeckSurf.size() > 0)
{
vector<Handle(Geom_Curve)> curvesL;
vector<Handle(Geom_Curve)> curvesR;
vector<gp_Pnt> psL;
vector<gp_Pnt> psR;
// ExtracteLine(dataMD.m_mapMainDeckSurf.begin()->first,-2,0,curvesL,curvesR); //怎么得到主甲板ID YY
//ExtracteLine(SurfID,-2,0,curvesL,curvesR); //怎么得到主甲板ID YY
if (curvesL.size() > 0)
{
double dlp,dfp;
dlp = curvesL[0]->FirstParameter();
dfp = curvesL[0]->LastParameter();
gp_Pnt pt1=curvesL[0]->Value(dlp);
gp_Pnt pt2=curvesL[0]->Value(dfp);
if (pt1.X() > pt2.X())
{
ListPnt.push_back(pt2);
ListPnta.push_back(pt2);
ptend = pt1;
}
else
{
ListPnt.push_back(pt1);
ListPnta.push_back(pt1);
ptend = pt2;
}
}else
{
gp_Pnt Or;
Or=gp_Pnt(-99999,0,0);
ListPnt.push_back(Or);
ListPnta.push_back(Or);
ptend = Or;
}
}
gp_Pnt Or;
Or=gp_Pnt(-99999,0,0);
map<int,double>::iterator it;
it=dataMD.m_mapStation.begin();
while(it!=dataMD.m_mapStation.end()){
curvesL.clear();
//ExtracteLine(SurfID,-1,it->second,curvesL,curvesR);
if (curvesL.size() > 0)
{
double dl,df;
dl = curvesL[0]->FirstParameter();
df = curvesL[0]->LastParameter();
gp_Pnt pt1=curvesL[0]->Value(dl);
gp_Pnt pt2=curvesL[0]->Value(df);
if ((ShipType == 2) && (AsymmetricType == 1))
{
if (pt1.Y()>pt2.Y())
{
ListPnt.push_back(pt2);
ListPnta.push_back(pt1);
}
else
{
ListPnt.push_back(pt1);
ListPnta.push_back(pt2);
}
}else{
if (pt1.Y()>pt2.Y())
{
ListPnt.push_back(pt1);
ListPnta.push_back(pt2);
}
else
{
ListPnt.push_back(pt2);
ListPnta.push_back(pt1);
}
}
}else
{
ListPnt.push_back(Or);
ListPnta.push_back(Or);
}
it++;
}
ListPnt.push_back(ptend);
ListPnta.push_back(ptend);
//OPoints.insert(pair<int,vector<gp_Pnt>>(FlagID*10000 ,ListPnt));
//OPoints.insert(pair<int,vector<gp_Pnt>>(FlagID*11000 ,ListPnta));
}
//////////////////////////////////////////////////////////////////////////
//剖面底线半宽,舭部升高的情况，需要算法 最低点
void OffsetGenerate1::CalSecLine()
{
vector<gp_Pnt> pSetF,pSetD;
OPoints.insert(make_pair(10001000,pSetF));
OPoints.insert(make_pair(10003000,pSetD));
//站
for(int i = 0; i < dataMD.m_mapStation.size(); i++)
{
double x = dataMD.m_mapStation[i];
vector<gp_Pnt> pSet;
TopoDS_Face f = CreateFace(-1, x);
vector<TopoDS_Edge> edges = GetShellSectionEdges(f);
Bnd_Box box;
double x1,x2,y1,y2,z1,z2;
for(vector<TopoDS_Edge>::iterator iter = edges.begin(); iter != edges.end(); iter++)
{
TopoDS_Edge edge = TopoDS::Edge(*iter);
BRepBndLib::Add(edge, box);
}
box.SetGap(0.0);
box.Get(x1,y1,z1,x2,y2,z2);
TopoDS_Face face = CreateFace(-3, z1);
for(vector<TopoDS_Edge>::iterator iter = edges.begin(); iter != edges.end(); iter++)
{
TopoDS_Edge edge = TopoDS::Edge(*iter);
vector<gp_Pnt> pSetTmp = GetSectionPoints(edge, face);
pSetTmp = CleanPoints(pSetTmp, -3, z1);
pSet = AddPoints(pSet, pSetTmp);
}
OPoints.insert(make_pair(10002000+i,pSet));
}
}
///基线求点,基线也就是水线为0时，Z=0，时的交线在各站号的点和剖面底线一致，但不存在舭部升高
void OffsetGenerate1::CalBaseLine()
{
TopoDS_Face face = CreateFace(-3, 0);
vector<TopoDS_Edge> edges = GetShellSectionEdges(face);
Bnd_Box box;
double x1,x2,y1,y2,z1,z2;
for(vector<TopoDS_Edge>::iterator iter = edges.begin(); iter != edges.end(); iter++)
{
TopoDS_Edge edge = TopoDS::Edge(*iter);
BRepBndLib::Add(edge, box);
}
box.SetGap(0.0);
box.Get(x1,y1,z1,x2,y2,z2);
//艏端点
vector<gp_Pnt> pSetF;
TopoDS_Face ff = CreateFace(-1, x2);
for(vector<TopoDS_Edge>::iterator iter = edges.begin(); iter != edges.end(); iter++)
{
TopoDS_Edge edge = TopoDS::Edge(*iter);
vector<gp_Pnt> pSetFTmp = GetSectionPoints1(edge, ff);
//pSetFTmp = CleanPoints(pSetFTmp, -1, x1);
pSetF = AddPoints(pSetF, pSetFTmp);
}
pSetF = GetExtremePoints(pSetF, 1);
OPoints.insert(make_pair(20001000,pSetF));
//艉端点
vector<gp_Pnt> pSetD;
TopoDS_Face fd = CreateFace(-1, x1);
for(vector<TopoDS_Edge>::iterator iter = edges.begin(); iter != edges.end(); iter++)
{
TopoDS_Edge edge = TopoDS::Edge(*iter);
vector<gp_Pnt> pSetDTmp = GetSectionPoints1(edge, fd);
//pSetDTmp = CleanPoints(pSetDTmp, -1, x2);
pSetD = AddPoints(pSetD, pSetDTmp);
}
pSetD = GetExtremePoints(pSetD, -1);
OPoints.insert(make_pair(20003000,pSetD));
//站
for(int i = 0; i < dataMD.m_mapStation.size(); i++)
{
double x = dataMD.m_mapStation[i];
vector<gp_Pnt> pSet;
TopoDS_Face f = CreateFace(-1, x);
for(vector<TopoDS_Edge>::iterator iter = edges.begin(); iter != edges.end(); iter++)
{
TopoDS_Edge edge = TopoDS::Edge(*iter);
vector<gp_Pnt> pSetTmp = GetSectionPoints(edge, f);
pSetTmp = CleanPoints(pSetTmp, -1, x);
pSet = AddPoints(pSet, pSetTmp);
}
OPoints.insert(make_pair(20002000+i,pSet));
}
}
//
// 水线求点
//
void OffsetGenerate1::CalWaterLine()
{
for(int w = 1; w < dataMD.m_mapWaterlinePos.size() ; w++)
{
TopoDS_Face face = CreateFace(-3, dataMD.m_mapWaterlinePos[w]);
vector<TopoDS_Edge> edges = GetShellSectionEdges(face);
Bnd_Box box;
double x1,x2,y1,y2,z1,z2;
for(vector<TopoDS_Edge>::iterator iter = edges.begin(); iter != edges.end(); iter++)
{
TopoDS_Edge edge = TopoDS::Edge(*iter);
BRepBndLib::Add(edge, box);
}
box.SetGap(0.0);
box.Get(x1,y1,z1,x2,y2,z2);
//艏端点
vector<gp_Pnt> pSetF;
TopoDS_Face ff = CreateFace(-1, x2);
for(vector<TopoDS_Edge>::iterator iter = edges.begin(); iter != edges.end(); iter++)
{
TopoDS_Edge edge = TopoDS::Edge(*iter);
vector<gp_Pnt> pSetFTmp = GetSectionPoints1(edge, ff);
//pSetFTmp = CleanPoints(pSetFTmp, -1, x1);
pSetF = AddPoints(pSetF, pSetFTmp);
}
pSetF = GetExtremePoints(pSetF, 1);
OPoints.insert(make_pair(30001000 + w * 10000,pSetF));
//艉端点
vector<gp_Pnt> pSetD;
TopoDS_Face fd = CreateFace(-1, x1);
for(vector<TopoDS_Edge>::iterator iter = edges.begin(); iter != edges.end(); iter++)
{
TopoDS_Edge edge = TopoDS::Edge(*iter);
vector<gp_Pnt> pSetDTmp = GetSectionPoints1(edge, fd);
//pSetDTmp = CleanPoints(pSetDTmp, -1, x2);
pSetD = AddPoints(pSetD, pSetDTmp);
}
pSetD = GetExtremePoints(pSetD, -1);
OPoints.insert(make_pair(30003000 + w * 10000,pSetD));
//站
for(int i = 0; i < dataMD.m_mapStation.size(); i++)
{
double x = dataMD.m_mapStation[i];
vector<gp_Pnt> pSet;
TopoDS_Face f = CreateFace(-1, x);
for(vector<TopoDS_Edge>::iterator iter = edges.begin(); iter != edges.end(); iter++)
{
TopoDS_Edge edge = TopoDS::Edge(*iter);
vector<gp_Pnt> pSetTmp = GetSectionPoints(edge, f);
pSetTmp = CleanPoints(pSetTmp, -1, x);
pSet = AddPoints(pSet, pSetTmp);
}
OPoints.insert(make_pair(30002000 + w * 10000 + i,pSet));
}
}
}
//面与船壳面的交线，返回一条此条交线，对返回的曲线进行拐点分析，如果有，进行曲线的拆分，返回多条曲线，及相应的
//极值点
//FreeBoard =1 取右舷 =-1 取左舷
//Flag = -1 YZ平面 =-2 XZ平面 =-3 XY平面 >0 为上甲板ID或者主甲板ID
//LType 判断线的类型，是否要进行拆分
void OffsetGenerate1::ExtracteLine(int Flag,double Pos,vector<Handle(Geom_Curve)>& CurL,vector<Handle(Geom_Curve)>& CurR,vector<gp_Pnt>& LPnts,vector<gp_Pnt>& RPnts,int LType)
{
TopoDS_Shape face,shell,shellL,shellR,tempshape1,tempshape2;
TopoDS_Edge secedge1,secedge2,secedge;
map<int,TopoDS_Shape>::iterator it;
gp_Pnt Or;
gp_Dir Norm;
switch(Flag)
{
case -1:
Or=gp_Pnt(Pos,0,0);
Norm=gp_Dir(1, 0.,0 );
break;
case -2:
Or=gp_Pnt(0,Pos,0.);
Norm=gp_Dir(0., 1, 0.);
break;
case -3:
Or=gp_Pnt(0,0,Pos);
Norm=gp_Dir(0., 0., 1.);
break;
default:
break;
}
if(Flag<0)
{
// gp_Pln pln(Or,Norm);
// Handle(Geom_Surface)aSurface =GC_MakePlane(pln).Value();
// //BRepBuilderAPI_MakeFace face1 =BRepBuilderAPI_MakeFace(aSurface);// XUEFENG DELETE 202009
// BRepBuilderAPI_MakeFace face1 =BRepBuilderAPI_MakeFace(aSurface, Precision::Confusion()); // XUEFENG ADDED 202009
// face=face1.Shape();
}
else
{
it=dataMD.m_mapAllTopoShapes.find(Flag);
if(it!=dataMD.m_mapAllTopoShapes.end())
{
face=it->second;
}
else
{
return;
}
}
if(dataMD.m_mapShellSurf.size()>0)
{}
else
{
return;
}
tempshape1=dataMD.m_mapAllTopoShapes.find(dataMD.m_mapShellSurf.begin()->first)->second;
/*switch(ShipType)
{
case 1:
case 4:
shell=dataMD.m_mapAllTopoShapes.find(dataMD.m_mapShellSurf.begin()->second.Src[0])->second;
break;
case 2:
tempshape1=dataMD.m_mapAllTopoShapes.find(dataMD.m_mapShellSurf.begin()->second.Src[0])->second;
tempshape2=dataMD.m_mapAllTopoShapes.find(dataMD.m_mapShellSurf.begin()->second.Src[1])->second ;
break;
default:
break;
}*/
list<TopoDS_Edge> edgelist;
list<TopoDS_Edge> edgelistL;
list<TopoDS_Edge> edgelistR;
TopoDS_Edge tpedge;
/*if(ShipType==1||ShipType==4)
{
BRepAlgoAPI_Section sec(face,shell,Standard_False);
sec.ComputePCurveOn1(Standard_True);
sec.Approximation(TopOpeBRepTool_APPROX);
sec.Build();
dataMD.GetInsectWirePts(sec.Shape(),edgelist);
if(edgelist.size()<1)
{
shell=dataMD.m_mapAllTopoShapes.find(dataMD.m_mapShellSurf.begin()->second.Src[1])->second;
BRepAlgoAPI_Section sec(face,shell,Standard_False);
sec.ComputePCurveOn1(Standard_True);
sec.Approximation(TopOpeBRepTool_APPROX);
sec.Build();
dataMD.GetInsectWirePts(sec.Shape(),edgelist);
}
if(edgelist.size()>0)
{
secedge=dataMD.SetInsectWireToEdge(edgelist);
//2016srq
//Handle_AIS_Shape AISShape=new AIS_Shape(secedge);
//myOCCViewer.myAISContext->Display(AISShape,true);
AnyCore::ASceneNodePtr AISShape=myOCCViewer.TopoShapeToASceneNode(secedge);
myOCCViewer.ShowSceneNode(AISShape,true);
}
double df1,de1;
Handle(Geom_Curve) curveL=BRep_Tool::Curve(secedge,df1,de1);
CurL.push_back(curveL);*/
/*}
else
{*/
BRepAlgoAPI_Section sec1(face,tempshape1,Standard_False);
sec1.ComputePCurveOn1(Standard_True);
sec1.Approximation(TopOpeBRepTool_APPROX);
sec1.Build();
TopoDS_Shape s =sec1.Shape();
dataMD.GetInsectWirePts(s,edgelistL);
secedge1=dataMD.SetInsectWireToEdge(edgelistL);
//if (tempshape2 != null){
/*BRepAlgoAPI_Section sec2(face,tempshape2,Standard_False);
sec2.ComputePCurveOn1(Standard_True);
sec2.Approximation(TopOpeBRepTool_APPROX);
sec2.Build();
dataMD.GetInsectWirePts(sec2.Shape(),edgelistR);
secedge2=dataMD.SetInsectWireToEdge(edgelistR);*/
//}
if(edgelistL.size()>0)
{
secedge1=dataMD.SetInsectWireToEdge(edgelistL);
//2016srq
/*Handle_AIS_Shape AISShape=new AIS_Shape(secedge1);
myOCCViewer.myAISContext->Display(AISShape,true);*/
// DELETE BY XUEFENG 20180731
// FOR CODES COMBINE
/*
AnyCore::ASceneNodePtr AISShape=myOCCViewer.TopoShapeToASceneNode(secedge1);
myOCCViewer.ShowSceneNode(AISShape,true);
*/
// END DELETE
}
/*if(edgelistR.size()>0)
{
secedge2=dataMD.SetInsectWireToEdge(edgelistR);
//Handle_AIS_Shape AISShape=new AIS_Shape(secedge2);
//myOCCViewer.myAISContext->Display(AISShape,true);
AnyCore::ASceneNodePtr AISShape=myOCCViewer.TopoShapeToASceneNode(secedge2);
myOCCViewer.ShowSceneNode(AISShape);
}*/
double df1,de1;//df2,de2; upd by yu for erase warning 14.8.27
Handle(Geom_Curve) curveL=BRep_Tool::Curve(secedge1,df1,de1);
CurL.push_back(curveL);
//Handle(Geom_Curve) curveR=BRep_Tool::Curve(secedge2,df2,de2);
//CurL=SplitGeomCurve(curveL,LPnts);
/*if(curveL->Value(df1).Y()>0||curveL->Value(de1).Y()>0)
{
CurL=SplitGeomCurve(curveL,LPnts);
CurR=SplitGeomCurve(curveR,RPnts);
}
else
{
CurR=SplitGeomCurve(curveL,LPnts);
CurL=SplitGeomCurve(curveR,RPnts);
}*/
//}
}
//针对不是和船壳面求交的情况
void OffsetGenerate1::ExtracteLine(int SurfID,int Flag,double Pos,vector<Handle(Geom_Curve)>& CurL,vector<Handle(Geom_Curve)>& CurR)
{
TopoDS_Shape face,shell,shellL,shellR,tempshape1,tempshape2;
TopoDS_Edge secedge1,secedge2,secedge;
map<int,TopoDS_Shape>::iterator it;
gp_Pnt Or;
gp_Dir Norm;
switch(Flag)
{
case -1:
Or=gp_Pnt(Pos,0,0);
Norm=gp_Dir(1, 0.,0 );
break;
case -2:
Or=gp_Pnt(0,Pos,0.);
Norm=gp_Dir(0., 1, 0.);
break;
case -3:
Or=gp_Pnt(0,0,Pos);
Norm=gp_Dir(0., 0., 1.);
break;
default:
break;
}
if(Flag<0)
{
// gp_Pln pln(Or,Norm);
// Handle(Geom_Surface)aSurface =GC_MakePlane(pln).Value();
// //BRepBuilderAPI_MakeFace face1 =BRepBuilderAPI_MakeFace(aSurface);// XUEFENG DELETE 202009
// BRepBuilderAPI_MakeFace face1 =BRepBuilderAPI_MakeFace(aSurface, Precision::Confusion()); // XUEFENG ADDED 202009
// face=face1.Shape();
}
else
{
it=dataMD.m_mapAllTopoShapes.find(Flag);
if(it!=dataMD.m_mapAllTopoShapes.end())
{
face=it->second;
}
else
{
return;
}
}
it=dataMD.m_mapAllTopoShapes.find(SurfID);
if(it!=dataMD.m_mapAllTopoShapes.end())
{
shell=it->second;
}
else
{
return;
}
list<TopoDS_Edge> edgelist;
list<TopoDS_Edge> edgelistL;
list<TopoDS_Edge> edgelistR;
TopoDS_Edge tpedge;
if(ShipType==1||ShipType==4)
{
BRepAlgoAPI_Section sec(face,shell,Standard_False);
sec.ComputePCurveOn1(Standard_True);
sec.Approximation(TopOpeBRepTool_APPROX);
sec.Build();
TopoDS_Shape s =sec.Shape();
dataMD.GetInsectWirePts(s,edgelist);
if(edgelist.size()<1)
{
shell=dataMD.m_mapAllTopoShapes.find(SurfID)->second;
BRepAlgoAPI_Section sec(face,shell,Standard_False);
sec.ComputePCurveOn1(Standard_True);
sec.Approximation(TopOpeBRepTool_APPROX);
sec.Build();
s =sec.Shape();
dataMD.GetInsectWirePts(s,edgelist);
}
if(edgelist.size()>0)
{
secedge=dataMD.SetInsectWireToEdge(edgelist);
//2016srq
/*Handle_AIS_Shape AISShape=new AIS_Shape(secedge);
myOCCViewer.myAISContext->Display(AISShape,true);
Handle_AIS_Shape AISShape1=new AIS_Shape(shell);
myOCCViewer.myAISContext->Display(AISShape1,true);*/
// DELETE BY XUEFENG 20180731
// FOR CODES COMBINE
/*
AnyCore::ASceneNodePtr AISShape=myOCCViewer.TopoShapeToASceneNode(secedge);
myOCCViewer.ShowSceneNode(AISShape);
AnyCore::ASceneNodePtr AISShape1=myOCCViewer.TopoShapeToASceneNode(shell);
myOCCViewer.ShowSceneNode(AISShape1);
*/
// END DELETE
}
double df1,de1;
Handle(Geom_Curve) curveL=BRep_Tool::Curve(secedge,df1,de1);
CurL.push_back(curveL);
//CurL = curveL;
//CurL=SplitGeomCurve(curveL,LPnts);
//if(curveL->Value(df1).Y()>0||curveL->Value(de1).Y()>0)
//{
// CurL=SplitGeomCurve(curveL,LPnts);
// //CurR=SplitGeomCurve(curveR,RPnts);
//}
//else
//{
// CurR=SplitGeomCurve(curveL,LPnts);
// //CurL=SplitGeomCurve(curveR,RPnts);
//}
}
else
{
BRepAlgoAPI_Section sec1(face,tempshape1,Standard_False);
sec1.ComputePCurveOn1(Standard_True);
sec1.Approximation(TopOpeBRepTool_APPROX);
BRepAlgoAPI_Section sec2(face,tempshape2,Standard_False);
sec2.ComputePCurveOn1(Standard_True);
sec2.Approximation(TopOpeBRepTool_APPROX);
sec1.Build();
TopoDS_Shape s =sec1.Shape();
dataMD.GetInsectWirePts(s,edgelistL);
secedge1=dataMD.SetInsectWireToEdge(edgelistL);
sec2.Build();
s =sec2.Shape();
dataMD.GetInsectWirePts(s,edgelistR);
secedge2=dataMD.SetInsectWireToEdge(edgelistR);
double df1,df2,de1,de2;
Handle(Geom_Curve) curveL=BRep_Tool::Curve(secedge1,df1,de1);
Handle(Geom_Curve) curveR=BRep_Tool::Curve(secedge2,df2,de2);
/*if(curveL->Value(df1).Y()>0||curveL->Value(de1).Y()>0)
{
CurL=SplitGeomCurve(curveL,LPnts);
CurR=SplitGeomCurve(curveR,RPnts);
}
else
{
CurR=SplitGeomCurve(curveL,LPnts);
CurL=SplitGeomCurve(curveR,RPnts);
}*/
}
}
/// <summary>
/// 自动拆分几何曲线（通过峰值、拐点///极值点）
/// </summary>
/// <param name="curve"></param>
/// <returns></returns>
vector<Handle(Geom_Curve)> OffsetGenerate1::SplitGeomCurve(Handle(Geom_Curve) curve, vector<gp_Pnt>& pnts)
{
//Handle(Geom_Curve) aCur = BRep_Tool::Curve(edge,df,dl);
//TopoDS_Edge
map<double,gp_Pnt> mapTempPnts;
map<double,gp_Pnt>::iterator it;
vector<Handle(Geom_Curve)> curves;
gp_Pnt beginP,endP,tempP;
double tempX,tempY,tempZ,tempPara;
gp_Pnt Or;
gp_Dir Norm;
gp_Pln pln;
Geom2dLProp_CurAndInf2d curpro;
Handle(Geom_BSplineCurve) myBSplCurve= Handle(Geom_BSplineCurve)::DownCast( curve);
Handle(Geom_Curve) myCurve=myBSplCurve;
beginP=myBSplCurve->StartPoint();
endP=myBSplCurve->EndPoint();
tempX=abs(beginP.X()-endP.X());
tempY=abs(beginP.Y()-endP.Y());
tempZ=abs(beginP.Z()-endP.Z());
/*if(tempX<10e-6)
{
Or=gp_Pnt(beginP.X(),0,0);
Norm=gp_Dir(1, 0,0 );
}
else if(tempY<10e-6)
{
Or=gp_Pnt(0,beginP.Y(),0);
Norm=gp_Dir(0, 1,0 );
}*/
//else
if(tempZ<10e-6)
{
Or=gp_Pnt(0,0,beginP.Z());
Norm=gp_Dir(0, 0,1 );
}
/*else
{
return curves;
}*/
mapTempPnts.insert(make_pair(myBSplCurve->FirstParameter(),beginP));
mapTempPnts.insert(make_pair(myBSplCurve->LastParameter(),endP));
pln=gp_Pln(Or,Norm);
Handle(Geom2d_Curve) curve2D=GeomAPI::To2d(myCurve,pln);
curpro.Perform(curve2D);
int num=curpro.NbPoints();
for(int i=1;i<=num;i++)
{
if(curpro.Type(i)==LProp_MinCur)
{
tempPara=curpro.Parameter(i);
tempP=myBSplCurve->Value(tempPara);
mapTempPnts.insert(make_pair(tempPara,tempP));
}
if(curpro.Type(i)==LProp_MaxCur)
{
tempPara=curpro.Parameter(i);
tempP=myBSplCurve->Value(tempPara);
mapTempPnts.insert(make_pair(tempPara,tempP));
}
}
if(mapTempPnts.size()>0)
{
for(it=mapTempPnts.begin();it!=mapTempPnts.end();it++)
{
pnts.push_back(it->second);
}
}
if(pnts.size()>0)
{
for(int j=0;j<pnts.size()-2;j++)
{
Handle(Geom_Curve) trimedCurve;
dataMD.TrimEdgeBy2Points(curve,pnts[j],pnts[j+1],trimedCurve);
curves.push_back(trimedCurve);
TopoDS_Edge edge=BRepBuilderAPI_MakeEdge(trimedCurve);
//2016srq
/*Handle_AIS_Shape AISShape=new AIS_Shape(edge);
myOCCViewer.myAISContext->Display(AISShape,true);*/
// DELETE BY XUEFENG 20180731
// FOR CODES COMBINE
/*
AnyCore::ASceneNodePtr AISShape=myOCCViewer.TopoShapeToASceneNode(edge);
myOCCViewer.ShowSceneNode(AISShape);
*/
// END DELETE
}
}
else
{
curves.push_back(curve);
}
////pnts = new vector<gp_Pnt>();//拐点存储
////curves = new vector<Geom_Curve>();
return curves;
}
vector<gp_Pnt> OffsetGenerate1::CalPoints(int ID)
{
vector<gp_Pnt> listPnt;
double df,dl;
map<int,TopoDS_Shape>::iterator it;
it=dataMD.m_mapAllTopoShapes.find(ID);
if(it!=dataMD.m_mapAllTopoShapes.end())
{
TopoDS_Edge edge=TopoDS::Edge(it->second);
Handle_Geom_Curve curve=BRep_Tool::Curve(edge,df,dl);
listPnt=CalPoints(curve,df,dl);
}
//CalPoints(Handle_Geom_Curve curve,int index)
return listPnt;
}
//Flag 当为隧道型船舶
vector<gp_Pnt> OffsetGenerate1::CalPoints(Handle_Geom_Curve curve,gp_Pnt df,gp_Pnt dl)
{
vector<gp_Pnt> listPnt;
int length = 0;
gp_Pnt pt1=df;
gp_Pnt pt2=dl;
listPnt.push_back(pt1);
int i = 0;
map<int,double>::iterator it;
it=dataMD.m_mapStation.begin();
while(it!=dataMD.m_mapStation.end()){
vector<gp_Pnt> Points = ExtractePoint(curve,0,it->second);
int len = Points.size();
if ((ShipType == 1))
{
//取左舷
if (len >1)
{
if (Points[0].Y() > Points[len-1].Y())
listPnt.push_back(Points[0]);
else
listPnt.push_back(Points[len-1]);
}else
{
gp_Pnt Or;
Or=gp_Pnt(-99999,0,0);
listPnt.push_back(Or);
}
}
if (ShipType == 4)
{
gp_Pnt Or1=gp_Pnt(-99999,0,0);
int vFlag = 0;
for (int i=0;i<len;i++)
if (Points[0].Y() < 0)
vFlag ++;
if (vFlag == len) //判断点如果都小于0的情况
{
for (int i=0;i<3;i++)
listPnt.push_back(Or1);
}else
{
switch (len)
{
case 1:
if (Points[0].Y() > 0)
{
listPnt.push_back(Or1);
listPnt.push_back(Points[0]);
listPnt.push_back(Points[0]);
}
break;
case 2:
if (Points[0].Y() > Points[1].Y())
{
listPnt.push_back(Points[0]);
listPnt.push_back(Or1);
listPnt.push_back(Points[0]);
}
else
{
listPnt.push_back(Points[1]);
listPnt.push_back(Or1);
listPnt.push_back(Points[1]);
}
break;
case 3:
case 4:
case 5:
if (Points[0].Y() > Points[len-1].Y())
{
listPnt.push_back(Points[0]);
listPnt.push_back(Points[1]);
listPnt.push_back(Or1);
}
else
{
listPnt.push_back(Points[len-1]);
listPnt.push_back(Points[len-2]);
listPnt.push_back(Or1);
}
default:
if (Points[0].Y() > Points[len-1].Y())
{
listPnt.push_back(Points[0]);
listPnt.push_back(Points[1]);
listPnt.push_back(Points[2]);
}
else
{
listPnt.push_back(Points[len-1]);
listPnt.push_back(Points[len-2]);
listPnt.push_back(Points[len-3]);
}
}
}
}
if ((ShipType == 2))
{
//取左舷
if (len >1){
if (AsymmetricType == -1)
{
if (len >1)
{
if (Points[0].Y() > Points[len-1].Y()){
listPnt.push_back(Points[0]);
listPnt.push_back(Points[len-1]);}
else{
listPnt.push_back(Points[0]);
listPnt.push_back(Points[len-1]);}
}
}
else
{
if (len >1)
{
if (Points[0].Y() < Points[len-1].Y()){
listPnt.push_back(Points[0]);
listPnt.push_back(Points[len-1]);}
else{
listPnt.push_back(Points[0]);
listPnt.push_back(Points[len-1]);}
}
}
}
else
{
gp_Pnt Or;
Or=gp_Pnt(-99999,0,0);
listPnt.push_back(Or);
gp_Pnt Or1;
Or1=gp_Pnt(-99999,0,0);
listPnt.push_back(Or1);
}
}
++it;
}
listPnt.push_back(pt2);
return listPnt;
}
/// <summary>
/// 计算水线或者纵剖线的点,给出线，根据纵向X值，得出每个X值上的点，对于首艉端点，则在调用此函数时给出
///返回一组点，在调用此函数后，分解需要的点放入型值表表达变量中
/// </summary>
/// <param name="index">最大站点索引（全部为-1）</param>
/// <param name="YZ">是半宽y还是高度z</param>
/// <returns></returns>
vector<gp_Pnt> OffsetGenerate1::CalPoints(Handle_Geom_Curve curve,double df,double dl,int Flag)
{
vector<gp_Pnt> listPnt;
int length = 0;
//if (index == -1) length = mStationPos.size();
// else length = index;
gp_Pnt pt1=curve->Value(df);
gp_Pnt pt2=curve->Value(dl);
listPnt.push_back(pt1);
int i = 0;
map<int,double>::iterator it;
it=dataMD.m_mapStation.begin();
while(it!=dataMD.m_mapStation.end()){
vector<gp_Pnt> Points = ExtractePoint(curve,0,it->second);
if (Flag == 1){
int len = Points.size();
if (len >2)
{
if (fabs(Points[0].Y()) > fabs(Points[len-1].Y()))
{
listPnt.push_back(Points[0]);
listPnt.push_back(Points[1]);
listPnt.push_back(Points[2]);
}
else
{
listPnt.push_back(Points[2]);
listPnt.push_back(Points[1]);
listPnt.push_back(Points[0]);
}
}
else if (len = 2)
{
if (fabs(Points[0].Y()) > fabs(Points[1].Y()))
{
listPnt.push_back(Points[0]);
listPnt.push_back(Points[1]);
}
else
{
listPnt.push_back(Points[1]);
listPnt.push_back(Points[0]);
}
gp_Pnt Or;
Or=gp_Pnt(-99999,0,0);
listPnt.push_back(Or);
}
else if (len == 1)
{
listPnt.push_back(Points[0]);
for (int k=0;k<2;k++)
{
gp_Pnt Or;
Or=gp_Pnt(-99999,0,0);
listPnt.push_back(Or);
}
}
else
{
for (int k=0;k<3;k++)
{
gp_Pnt Or;
Or=gp_Pnt(-99999,0,0);
listPnt.push_back(Or);
}
}
}else{
if (Points.size() > 0)
listPnt.push_back(Points[0]);
else
{
gp_Pnt Or;
Or=gp_Pnt(-99999,0,0);
listPnt.push_back(Or);
}
}
++it;
}
listPnt.push_back(pt2);
return listPnt;
}
/// <summary>
/// 几何曲线与平面相交，求交点
/// </summary>
/// <returns></returns>
vector<gp_Pnt> OffsetGenerate1::ExtractePoint(Handle_Geom_Curve curve,int flag,double pos)
{
vector<gp_Pnt> points;
//////////
gp_Pnt Or;
gp_Dir Norm;
switch (flag)
{
case 0:
Or=gp_Pnt(pos,0,0);
Norm=gp_Dir(1, 0.,0 );
break;
case 1:
Or=gp_Pnt(0,pos,0);
Norm=gp_Dir(0, 1,0 );
break;
case 2:
Or=gp_Pnt(0,0,pos);
Norm=gp_Dir(0, 0.,1 );
break;
default:
break;
}
// gp_Pln pln(Or,Norm);
// Handle(Geom_Surface) aSurface =GC_MakePlane(pln).Value();
// GeomAPI_IntCS IntCS(curve,aSurface);
// if (IntCS.IsDone())
// {
// if (IntCS.NbPoints() > 0)
// {
// for (int j = 1; j <= IntCS.NbPoints(); j++)
// {
// points.push_back(IntCS.Point(j));
// }
// }
// }
return points;
}
/// <summary>
/// 获取曲线中直线段与曲线段的连接点
/// </summary>
/// <param name="curve"></param>
/// <returns></returns>
vector<gp_Pnt> OffsetGenerate1::GetInflectionPoints(Handle(Geom_Curve) curve)
{
vector<gp_Pnt> result;
vector<gp_Pnt> resultF;
vector<gp_Pnt> resultB;
std::vector<TopoDS_Edge> edgeSetF;
std::vector<gp_Pnt> pointSetF;
std::vector<TopoDS_Edge> edgeSetB;
std::vector<gp_Pnt> pointSetB;
int level = 1;
TopoDS_Edge edge = BRepBuilderAPI_MakeEdge(curve).Edge();
GProp_GProps System;
BRepGProp::LinearProperties(edge,System);
edgeSetF.push_back(edge);
double step = System.Mass() / 10000/*pow(10000.0, level)*/;
step = step < 0.01 ? step : 0.01;
edgeSetF = GetEdgeSet(edgeSetF, step, pointSetF);
resultF = GetIntersections(edgeSetF, pointSetF, level);
for(int i = edgeSetF.size() - 1 ;i > -1; i--)
{
edgeSetB.push_back(edgeSetF[i]);
}
for(int i = pointSetF.size() - 1 ;i > -1; i--)
{
pointSetB.push_back(pointSetF[i]);
}
resultB = GetIntersections(edgeSetB, pointSetB, level);
int count = resultB.size() + resultF.size();
double Y = 10000;
double YMax = -10000;
gp_Pnt tmp;
for(int i = 0; i < count; i++)
{
for(int j = 0; j < resultF.size(); j++)
{
if(resultF[j].Y() < Y && YMax < resultF[j].Y())
{
YMax = resultF[j].Y();
tmp = resultF[j];
}
}
for(int j = 0; j < resultB.size(); j++)
{
if(resultB[j].Y() < Y && YMax < resultB[j].Y())
{
YMax = resultB[j].Y();
tmp = resultB[j];
}
}
result.push_back(tmp);
Y = YMax;
YMax = -10000;
}
return result;
}
vector<gp_Pnt> OffsetGenerate1::GetIntersections(vector<TopoDS_Edge> &edgeSet, vector<gp_Pnt> &pointSet, int lev)
{
vector<gp_Pnt> result;
//pointSet.clear();
if (edgeSet.size() < 2)
{
return result;
}
//连续直线段的长度
double len = 0;
bool isline = false;
gp_Pnt pointStart, pointEnd;
pointStart = pointSet[0];
bool isStartPoint = true;
int edgeIndexStart;
// int edgeBefore; upd by yu for erase warning 14.8.27
for(int i = 0; i < edgeSet.size(); i++)
{
//if (i==(edgeSet.size()-1))
// break;
pointEnd = pointSet[i+1];
double dis = gp_Vec(pointStart,pointEnd).Magnitude();
double d1,d2;
Handle_Geom_Curve curve = BRep_Tool::Curve(edgeSet[i], d1, d2);
TopExp_Explorer ex;
ex.Init(edgeSet[i],TopAbs_VERTEX);
gp_Pnt p1 = BRep_Tool::Pnt(TopoDS::Vertex(ex.Current()));
ex.Next();
gp_Pnt p2 = BRep_Tool::Pnt(TopoDS::Vertex(ex.Current()));
//GeomAdaptor_Curve C(curve);
//GCPnts_AbscissaPoint myAlgo;
//len += myAlgo.Length(C);
GProp_GProps System;
BRepGProp::LinearProperties(edgeSet[i],System);
gp_Pnt G = System.CentreOfMass ();
len += System.Mass();
if(fabs(len - dis) < len * 0.02)
{
isline = true;
//len += dis - System.Mass();
continue;
}
else
{
if(isline)
{
if(!isStartPoint)
{
if(lev - 2 < 0)
{
result.push_back(pointStart);
}
else
{
vector<TopoDS_Edge> tmpEdgeSet;
vector<gp_Pnt> tmpPointSet;
tmpEdgeSet.push_back(edgeSet[edgeIndexStart]);
tmpEdgeSet.push_back(edgeSet[edgeIndexStart + 1]);
double tmpStep = System.Mass() / pow(10.0, lev - 1);
tmpEdgeSet = GetEdgeSet(tmpEdgeSet, tmpStep, tmpPointSet);
vector<gp_Pnt> tmpResult = GetIntersections(tmpEdgeSet, tmpPointSet, lev - 1);
for(int k = 0; k < tmpResult.size(); k++)
{
result.push_back(tmpResult[k]);
}
}
}
if(lev - 2 < 0)
{
result.push_back(pointSet[i]);
}
else
{
vector<TopoDS_Edge> tmpEdgeSet;
vector<gp_Pnt> tmpPointSet;
tmpEdgeSet.push_back(edgeSet[i - 1]);
tmpEdgeSet.push_back(edgeSet[i]);
double tmpStep = System.Mass() / pow(10.0, lev - 1);
tmpEdgeSet = GetEdgeSet(tmpEdgeSet, tmpStep, tmpPointSet);
vector<gp_Pnt> tmpResult = GetIntersections(tmpEdgeSet, tmpPointSet, lev - 1);
for(int k = 0; k < tmpResult.size(); k++)
{
result.push_back(tmpResult[k]);
}
}
pointStart = pointSet[i];
i--;
len = 0;
isline = false;
}
else
{
pointStart = pointEnd;
edgeIndexStart = i;
len = 0;
isStartPoint = false;
}
}
}
if(isline && !isStartPoint)
{
if(lev - 2 < 0)
{
result.push_back(pointStart);
}
else
{
vector<TopoDS_Edge> tmpEdgeSet;
vector<gp_Pnt> tmpPointSet;
tmpEdgeSet.push_back(edgeSet[edgeIndexStart]);
tmpEdgeSet.push_back(edgeSet[edgeIndexStart + 1]);
TopExp_Explorer ex;
ex.Init(edgeSet[edgeIndexStart],TopAbs_VERTEX);
gp_Pnt p1 = BRep_Tool::Pnt(TopoDS::Vertex(ex.Current()));
ex.Next();
gp_Pnt p2 = BRep_Tool::Pnt(TopoDS::Vertex(ex.Current()));
double tmpStep = gp_Vec(p1,p2).Magnitude() / pow(10.0, lev - 1);
tmpEdgeSet = GetEdgeSet(tmpEdgeSet, tmpStep, tmpPointSet);
vector<gp_Pnt> tmpResult = GetIntersections(tmpEdgeSet, tmpPointSet, lev - 1);
for(int k = 0; k < tmpResult.size(); k++)
{
result.push_back(tmpResult[k]);
}
}
}
return result;
}
vector<TopoDS_Edge> OffsetGenerate1::GetEdgeSet(vector<TopoDS_Edge>& edgeSet, double step , vector<gp_Pnt>& pointSet)
{
vector<TopoDS_Edge> newEdgeSet;
pointSet.clear();
for(vector<TopoDS_Edge>::iterator iter = edgeSet.begin(); iter != edgeSet.end(); iter++)
{
TopoDS_Edge edge = *iter;
double df,dl;
Handle(Geom_Curve) aCur = BRep_Tool::Curve(edge,df,dl);
TopExp_Explorer ex(edge, TopAbs_VERTEX);
gp_Pnt startPoint = BRep_Tool::Pnt(TopoDS::Vertex(ex.Current()));
ex.Next();
gp_Pnt endPoint = BRep_Tool::Pnt(TopoDS::Vertex(ex.Current()));
Standard_Real st1 = 0;
Standard_Real st2 = 0;
double len = 0;
//GeomAPI_ProjectPointOnCurve Projector1 (startPoint, aCur); //gp_Pnt Bpnt
//GeomAPI_ProjectPointOnCurve Projector2 (endPoint, aCur); //gp_Pnt Bpnt
//st1 = Projector1.LowerDistanceParameter();
//st2 = Projector2.LowerDistanceParameter();
BaseAlgo algo;
st1 = algo.ProjectPointOnCurvePara(edge, startPoint);
st2 = algo.ProjectPointOnCurvePara(edge, startPoint);
len = fabs(st2 - st1);
double surplus = len;
double head = st1;
while(surplus > step * 1.5)
{
double tail = head + step;
Handle(Geom_TrimmedCurve) myTrimmed = new Geom_TrimmedCurve(aCur, head, tail);
newEdgeSet.push_back(BRepBuilderAPI_MakeEdge(myTrimmed).Edge());
if(pointSet.size() < 1)
{
pointSet.push_back(aCur->Value(head));
}
pointSet.push_back(aCur->Value(tail));
head = tail;
surplus -= step;
}
Handle(Geom_TrimmedCurve) myTrimmed = new Geom_TrimmedCurve(aCur, head, st2);
newEdgeSet.push_back(BRepBuilderAPI_MakeEdge(myTrimmed).Edge());
if(pointSet.size() < 0)
{
pointSet.push_back(aCur->Value(head));
}
pointSet.push_back(aCur->Value(st2));
}
return newEdgeSet;
}
//*根据站和水线位置，计算船壳相应位置的型值点 yc 20141222
int OffsetGenerate1::GetOffsetTableData(int stationNum, double stations[],int waterlineNum,double waterlines[], int pNum[], OffsetTablePoint *pnts, OffsetTablePoint *zmaxPnts,double *zmins,OffsetTablePoint *yPnts)
{
vector<gp_Pnt> pSet;
vector<gp_Pnt> zpmaxSet;
vector<gp_Pnt> ypSet;
OCCLib lib;
BaseAlgo algo;
//获取船壳
TopoDS_Shape shipShell;
if(dataMD.m_mapShellSurf.size()==1)
shipShell=dataMD.m_mapAllTopoShapes.find(dataMD.m_mapShellSurf.begin()->first)->second;
if(shipShell.IsNull())
{
return 0;
}
for(int i = 0; i < stationNum; i++)
{
double x = stations[i];
//生成横剖面
TopoDS_Face stationFace = lib.CreateFaceByPoints(gp_Pnt(x, 200, 200),gp_Pnt(x, -200, 200),gp_Pnt(x, -200, -200),gp_Pnt(x, 200, -200));
Handle(Geom_Surface) aSurface = BRep_Tool::Surface(stationFace);
//求交线
TopoDS_Shape stationLine;
BRepAlgoAPI_Section asect(stationFace,shipShell,Standard_False);
asect.ComputePCurveOn1(Standard_True);
asect.Approximation(Standard_True);
asect.Build();
TopoDS_Shape splitResult = asect.Shape();
for(int j = 0; j < waterlineNum; j++)
{
double z = waterlines[j];
//生成水线面
TopoDS_Face waterLineFace = lib.CreateFaceByPoints(gp_Pnt(200, 200, z),gp_Pnt(200, -200, z),gp_Pnt(-200, -200, -z),gp_Pnt(-200, 200, -z));
//与横剖线计算交点
vector<gp_Pnt> pSetTmp;
for(TopExp_Explorer ex(splitResult, TopAbs_EDGE); ex.More(); ex.Next())
{
double first,last;
TopoDS_Edge edge = TopoDS::Edge(ex.Current());
Handle(Geom_Curve) curve = BRep_Tool::Curve(edge, first, last);
curve = new Geom_TrimmedCurve(curve, first, last);
GeomAPI_IntCS intcs_sn(curve, aSurface);
if (!intcs_sn.IsDone())
{
return 0;
}
int nPnt=intcs_sn.NbPoints();
for(int k = 0; k < nPnt; k++)
{
gp_Pnt pnt = intcs_sn.Point(k + 1);
if((abs(pnt.X() - x) < Precision::Confusion() && abs(pnt.Z() - z) < Precision::Confusion()) && !IsFindPoint(pSetTmp, pnt))
{
pSetTmp.push_back(pnt);
}
}
}//for(TopExp_Explorer ex(splitResult, TopAbs_EDGE); ex.More(); ex.Next())
pNum[i * waterlineNum + j] = pSetTmp.size();
for(int k = 0; k < pSetTmp.size(); k++)
{
pSet.push_back(pSetTmp[k]);
}
}// for(int j = 0; j < waterlineNum; j++)
//计算甲板边线
gp_Pnt pZmax(-100,-100,-100), pZmin(100, 100, 100), pY(100,100,100);
Bnd_Box box;
for(TopExp_Explorer ex(splitResult, TopAbs_EDGE); ex.More(); ex.Next())
{
TopoDS_Edge edge = TopoDS::Edge(ex.Current());
gp_Pnt p1,p2;
algo.GetEdgeStartEndPoint(edge, p1,p2);
BRepBndLib::Add(edge, box);
if(p1.Z() > pZmax.Z())
{
pZmax = p1;
}
if(p2.Z() > pZmax.Z())
{
pZmax = p2;
}
if(abs(p1.Y()) < Precision::Confusion())
{
pY = p1;
}
if(abs(p2.Y()) < Precision::Confusion())
{
pY = p2;
}
}
zpmaxSet.push_back(pZmax);
ypSet.push_back(pY);
double x1,x2,y1,y2,z1,z2;
box.SetGap(0.0);
box.Get(x1,y1,z1,x2,y2,z2);
zmins[i] = z1;
}//for(int i = 0; i < stationNum; i++)
for(int i = 0; i < pSet.size(); i++)
{
pnts[i].X = pSet[i].X();
pnts[i].Y = pSet[i].Y();
pnts[i].Z = pSet[i].Z();
}
for(int i = 0; i < zpmaxSet.size(); i++)
{
zmaxPnts[i].X = zpmaxSet[i].X();
zmaxPnts[i].Y = zpmaxSet[i].Y();
zmaxPnts[i].Z = zpmaxSet[i].Z();
}
for(int i = 0; i < ypSet.size(); i++)
{
yPnts[i].X = ypSet[i].X();
yPnts[i].Y = ypSet[i].Y();
yPnts[i].Z = ypSet[i].Z();
}
}
//判断点是否在集合中
bool OffsetGenerate1::IsFindPoint(vector<gp_Pnt> pSet, gp_Pnt p)
{
bool isfind = false;
for(int i = 0; i < pSet.size(); i++)
{
if(p.Distance(pSet[i]) < Precision::Confusion())
{
isfind = true;
break;
}
}
return isfind;
}
//*根据站和水线位置，计算船壳相应位置的型值点 yc 20141222
/// <summary>
/// 生成水线面，横剖面，纵剖面
/// </summary>
/// <param name="flag"> -1 x平面 =-2 y平面 =-3 z平面 </param>
/// <param name="pos"> 位置 </param>
/// <returns></returns>
TopoDS_Face OffsetGenerate1::CreateFace(int flag, double pos)
{
TopoDS_Face face;
gp_Pnt Or;
gp_Dir Norm;
switch(flag)
{
case -1:
Or=gp_Pnt(pos,0,0);
Norm=gp_Dir(1, 0.,0 );
break;
case -2:
Or=gp_Pnt(0,pos,0.);
Norm=gp_Dir(0., 1, 0.);
break;
case -3:
Or=gp_Pnt(0,0,pos);
Norm=gp_Dir(0., 0., 1.);
break;
default:
return face;
}
// gp_Pln pln(Or,Norm);
// Handle(Geom_Surface) aSurface =GC_MakePlane(pln).Value();
// //BRepBuilderAPI_MakeFace face1 =BRepBuilderAPI_MakeFace(aSurface);// XUEFENG DELETE 202009
// BRepBuilderAPI_MakeFace face1 =BRepBuilderAPI_MakeFace(aSurface, Precision::Confusion()); // XUEFENG ADDED 202009
// face=face1.Face();
return face;
}
/// <summary>
/// 求交线
/// </summary>
/// <param name="shape1"> </param>
/// <param name="shape2"> </param>
/// <returns></returns>
vector<TopoDS_Edge> OffsetGenerate1::GetSectionEdges(TopoDS_Shape shape1, TopoDS_Shape shape2)
{
vector<TopoDS_Edge> edges;
BRepAlgoAPI_Section asect(shape1,shape2,Standard_False);
asect.ComputePCurveOn1(Standard_True);
asect.Approximation(Standard_True);
asect.Build();
TopoDS_Shape splitResult = asect.Shape();
for (TopExp_Explorer Ex(splitResult,TopAbs_EDGE); Ex.More(); Ex.Next())
{
TopoDS_Edge anEdge =TopoDS::Edge(Ex.Current());
edges.push_back(anEdge);
//2016srq
////Handle_AIS_Shape aisShape=new AIS_Shape(anEdge);
////
//// myOCCViewer.myAISContext->Display(aisShape,false);
//AnyCore::ASceneNodePtr aisShape=myOCCViewer.TopoShapeToASceneNode(anEdge);
//
// myOCCViewer.ShowSceneNode(aisShape,false);
}
return edges;
}
/// <summary>
/// 求半船壳
/// </summary>
/// <param name="shape1"> </param>
/// <returns></returns>
void OffsetGenerate1::GetHalfShell()
{
if(dataMD.m_mapShellSurf.size()==1)
{
TopoDS_Shape shape2=dataMD.m_mapAllTopoShapes.find(dataMD.m_mapShellSurf.begin()->first)->second;
OCCLib lib;
TopoDS_Solid solid = lib.CreateSolid(gp_Pnt(-1000,0,-10), 2000,100,100);
BRepAlgoAPI_Common newcut(solid ,shape2);
if(newcut.IsDone())
{
halfShell = newcut.Shape();
}
}
return ;
}
/// <summary>
/// 与船壳面求交线
/// </summary>
/// <param name="shape1"> </param>
/// <returns></returns>
vector<TopoDS_Edge> OffsetGenerate1::GetShellSectionEdges(TopoDS_Shape shape1)
{
vector<TopoDS_Edge> edges;
edges = GetSectionEdges(shape1, halfShell);
return edges;
}
/// <summary>
/// 线面求交点
/// </summary>
/// <param name="shape1"> </param>
/// <returns></returns>
vector<gp_Pnt> OffsetGenerate1::GetSectionPoints(TopoDS_Edge edge, TopoDS_Face face)
{
vector<gp_Pnt> pnts;
double first,last;
Handle(Geom_Curve) curve = BRep_Tool::Curve(edge, first, last);
curve = new Geom_TrimmedCurve(curve, first, last);
Handle(Geom_Surface) aSurface = BRep_Tool::Surface(face);
GeomAPI_IntCS intcs_sn(curve, aSurface);
if (!intcs_sn.IsDone())
{
return pnts;
}
int nPnt=intcs_sn.NbPoints();
for(int k = 0; k < nPnt; k++)
{
gp_Pnt pnt = intcs_sn.Point(k + 1);
pnts.push_back(pnt);
}
//if(pnts.size() == 0)
//{
// return GetSectionPoints1(edge, face);
//}
return pnts;
}
vector<gp_Pnt> OffsetGenerate1::GetSectionPoints1(TopoDS_Edge edge, TopoDS_Shape face)
{
vector<gp_Pnt> pnts;
BRepExtrema_DistShapeShape inter;
inter.LoadS1(edge);
inter .LoadS2(face);
inter.Perform();
int nPnt= inter.NbSolution();
for(int k = 0; k < nPnt; k++)
{
gp_Pnt pnt1 = inter.PointOnShape1(k+1);
gp_Pnt pnt2 = inter.PointOnShape2(k + 1);
//if(pnt1.Distance(pnt2) > Precision::Confusion())
//{
// continue;
//}
pnts.push_back(pnt1);
}
return pnts;
}
//根据x，y或z的值，删除点
vector<gp_Pnt> OffsetGenerate1::CleanPoints(vector<gp_Pnt> pSet, int flag, double pos)
{
vector<gp_Pnt> pnts;
for(int i = 0; i < pSet.size(); i++)
{
switch(flag)
{
case -1:
if(abs(pSet[i].X() - pos) <Precision::Confusion())
{
pnts.push_back(pSet[i]);
}
break;
case -2:
if(abs(pSet[i].Y() - pos) <Precision::Confusion())
{
pnts.push_back(pSet[i]);
}
break;
case -3:
if(abs(pSet[i].Z() - pos) <Precision::Confusion())
{
pnts.push_back(pSet[i]);
}
break;
default:
break;
}
}
return pnts;
}
//合并点集合
vector<gp_Pnt> OffsetGenerate1::AddPoints(vector<gp_Pnt> pSet1, vector<gp_Pnt> pSet2)
{
vector<gp_Pnt> pnts;
for(int i = 0; i < pSet1.size(); i++)
{
pnts.push_back(pSet1[i]);
}
for(int i = 0; i < pSet2.size(); i++)
{
bool isfind = false;
for(int j = 0; j < pnts.size(); j++)
{
if(pSet2[i].Distance(pnts[j]) < Precision::Confusion())
{
isfind = true;
break;
}
}
if(!isfind)
{
pnts.push_back(pSet2[i]);
}
}
return pnts;
}
//计算极值点
vector<gp_Pnt> OffsetGenerate1::GetExtremePoints(vector<gp_Pnt> pSet, int flag)
{
vector<gp_Pnt> pnts;
double val ;
switch(flag)
{
case 1:
val = -1e10;
for(int i = 0; i < pSet.size(); i++)
{
gp_Pnt p = pSet[i];
if(abs(p.X() - val) < Precision::Confusion())
{
pnts.push_back(p);
}
else if(p.X() > val)
{
val = p.X();
pnts.clear();
pnts.push_back(p);
}
}
break;
case 2:
val = -1e10;
for(int i = 0; i < pSet.size(); i++)
{
gp_Pnt p = pSet[i];
if(abs(p.Y() - val) < Precision::Confusion())
{
pnts.push_back(p);
}
else if(p.Y() > val)
{
val = p.Y();
pnts.clear();
pnts.push_back(p);
}
}
break;
case 3:
val = -1e10;
for(int i = 0; i < pSet.size(); i++)
{
gp_Pnt p = pSet[i];
if(abs(p.Z() - val) < Precision::Confusion())
{
pnts.push_back(p);
}
else if(p.Z() > val)
{
val = p.Z();
pnts.clear();
pnts.push_back(p);
}
}
break;
case -1:
val = 1e10;
for(int i = 0; i < pSet.size(); i++)
{
gp_Pnt p = pSet[i];
if(abs(p.X() - val) < Precision::Confusion())
{
pnts.push_back(p);
}
else if(p.X() < val)
{
val = p.X();
pnts.clear();
pnts.push_back(p);
}
}
break;
case -2:
val = 1e10;
for(int i = 0; i < pSet.size(); i++)
{
gp_Pnt p = pSet[i];
if(abs(p.Y() - val) < Precision::Confusion())
{
pnts.push_back(p);
}
else if(p.Y() < val)
{
val = p.Y();
pnts.clear();
pnts.push_back(p);
}
}
break;
case -3:
val = 1e10;
for(int i = 0; i < pSet.size(); i++)
{
gp_Pnt p = pSet[i];
if(abs(p.Z() - val) < Precision::Confusion())
{
pnts.push_back(p);
}
else if(p.Z() < val)
{
val = p.Z();
pnts.clear();
pnts.push_back(p);
}
}
break;
default:
break;
}
return pnts;
}
//甲板下移76mm
int OffsetGenerate1::GetMarginLineleData(int lens[], OffsetTablePoint *pnts)
{
TopoDS_Shape TopoShape,sshape1,sshape2, topoSolid;
//GetHalfShell();
if(dataMD.m_mapMainDeckSurf.size()==1)
sshape1=dataMD.m_mapAllTopoShapes.find(dataMD.m_mapMainDeckSurf.begin()->first)->second;
else
return -1; //Volume;
if(dataMD.m_mapShellSurf.size()==1)
sshape2=dataMD.m_mapAllTopoShapes.find(dataMD.m_mapShellSurf.begin()->first)->second;
else
return -1; //Volume;
//gp_Trsf theTransformation;
//theTransformation.SetTranslation(gp_Vec(0,0,-0.076));
//sshape1= BRepBuilderAPI_Transform(sshape1, theTransformation, false);
vector<TopoDS_Edge> edges;
//vector<TopoDS_Edge> edges = GetSectionEdges(sshape1, sshape2);
//甲板外边线
for(TopExp_Explorer ex(sshape1, TopAbs_EDGE); ex.More(); ex.Next())
{
TopoDS_Edge edge = TopoDS::Edge(ex.Current());
Bnd_Box boxE;
double xE1,xE2,yE1,yE2,zE1,zE2;
BRepBndLib::Add(edge, boxE);
boxE.SetGap(0.0);
boxE.Get(xE1,yE1,zE1,xE2,yE2,zE2);
if(yE1 < 0 || yE2 < 0)//负半边
{
continue;
}
else if(abs(yE1) <Precision::Confusion() && abs(yE2) < Precision::Confusion())//y=0
{
continue;
}
edges.push_back(edge);
}
Bnd_Box box;
double x1,x2,y1,y2,z1,z2;
for(vector<TopoDS_Edge>::iterator iter = edges.begin(); iter != edges.end(); iter++)
{
TopoDS_Edge edge = TopoDS::Edge(*iter);
BRepBndLib::Add(edge, box);
}
box.SetGap(0.0);
box.Get(x1,y1,z1,x2,y2,z2);
//-----------------------------------------------------------------------------------------------------------------------------
//艉端点
vector<gp_Pnt> pSetD;
TopoDS_Face fd = CreateFace(-1, x1);
for(vector<TopoDS_Edge>::iterator iter = edges.begin(); iter != edges.end(); iter++)
{
TopoDS_Edge edge = TopoDS::Edge(*iter);
vector<gp_Pnt> pSetDTmp = GetSectionPoints1(edge, fd);
//pSetDTmp = CleanPoints(pSetDTmp, -1, x2);
pSetD = AddPoints(pSetD, pSetDTmp);
}
pSetD = GetExtremePoints(pSetD, -1);
double xD = 10000,zD = 0;
for(int i = 0; i < pSetD.size(); i++)
{
if(xD > pSetD[i].X())
{
xD = pSetD[i].X();
zD = pSetD[i].Z();
}
}
fd = CreateFace(-3, zD - 0.076);
pSetD.clear();
vector<TopoDS_Edge> edgesD = GetSectionEdges(sshape2, fd);
for(vector<TopoDS_Edge>::iterator iter = edgesD.begin(); iter != edgesD.end(); iter++)
{
TopoDS_Edge edge = TopoDS::Edge(*iter);
vector<gp_Pnt> pSetDTmp = GetSectionPoints1(edge, fd);
//pSetDTmp = CleanPoints(pSetDTmp, -1, x2);
pSetD = AddPoints(pSetD, pSetDTmp);
}
pSetD = GetExtremePoints(pSetD, -1);
OPoints.insert(make_pair(OPoints.size(),pSetD));
//------------------------------------------------------------------------------------------------------
//站
int count = 0;
for(int i = 0; i < dataMD.m_mapStation.size(); i++)
{
double x = dataMD.m_mapStation[i];
vector<gp_Pnt> pSet;
//TopoDS_Face f = CreateFace(-1, x);
//vector<TopoDS_Edge> edgesS = GetSectionEdges(sshape2, f);
//if(edgesS.size() > 0)
//{
// Bnd_Box boxS;
// double xS1,xS2,yS1,yS2,zS1,zS2;
// for(vector<TopoDS_Edge>::iterator iter = edgesS.begin(); iter != edgesS.end(); iter++)
// {
// TopoDS_Edge edge = TopoDS::Edge(*iter);
// BRepBndLib::Add(edge, boxS);
// }
// boxS.SetGap(0.0);
// boxS.Get(xS1,yS1,zS1,xS2,yS2,zS2);
// f = CreateFace(-3, zS2- 0.076);
// for(vector<TopoDS_Edge>::iterator iter = edgesS.begin(); iter != edgesS.end(); iter++)
// {
// TopoDS_Edge edge = TopoDS::Edge(*iter);
// vector<gp_Pnt> pSetTmp = GetSectionPoints(edge, f);
// pSetTmp = CleanPoints(pSetTmp, -1, x);
// pSet = AddPoints(pSet, pSetTmp);
// count++;
// }
//}
TopoDS_Face f = CreateFace(-1, x);
double z = -1;
for(int k = 0; k < edges.size(); k++)
{
Bnd_Box boxE;
double xE1,xE2,yE1,yE2,zE1,zE2;
BRepBndLib::Add(edges[k], boxE);
boxE.SetGap(0.0);
boxE.Get(xE1,yE1,zE1,xE2,yE2,zE2);
if(xE2 < x || xE1 > x)
{
continue;
}
vector<gp_Pnt> pSetTmp = GetSectionPoints(edges[k], f);
if(pSetTmp.size() == 0)
{
continue;
}
z = pSetTmp[0].Z();
break;
}
if(z < 0)
{
continue;
}
TopoDS_Edge edge = BRepBuilderAPI_MakeEdge(gp_Pnt(x,100,z- 0.076), gp_Pnt(x,-100,z- 0.076));
vector<gp_Pnt> pSetTmp = GetSectionPoints1(edge, sshape2);
pSetTmp = CleanPoints(pSetTmp, -1, x);
pSet = AddPoints(pSet, pSetTmp);
OPoints.insert(make_pair(OPoints.size(),pSet));
}
//----------------------------------------------------------------------------------------------
//艏端点
vector<gp_Pnt> pSetF;
TopoDS_Face ff = CreateFace(-1, x2);
for(vector<TopoDS_Edge>::iterator iter = edges.begin(); iter != edges.end(); iter++)
{
TopoDS_Edge edge = TopoDS::Edge(*iter);
vector<gp_Pnt> pSetFTmp = GetSectionPoints1(edge, ff);
//pSetFTmp = CleanPoints(pSetFTmp, -1, x1);
pSetF = AddPoints(pSetF, pSetFTmp);
}
pSetF = GetExtremePoints(pSetF, 1);
double xF = -10000,zF = 0;
for(int i = 0; i < pSetF.size(); i++)
{
if(xF < pSetF[i].X())
{
xF = pSetF[i].X();
zF = pSetF[i].Z();
}
}
ff = CreateFace(-3, zF - 0.076);
pSetF.clear();
vector<TopoDS_Edge> edgesF = GetSectionEdges(sshape2, ff);
for(vector<TopoDS_Edge>::iterator iter = edgesF.begin(); iter != edgesF.end(); iter++)
{
TopoDS_Edge edge = TopoDS::Edge(*iter);
vector<gp_Pnt> pSetFTmp = GetSectionPoints1(edge, ff);
//pSetDTmp = CleanPoints(pSetDTmp, -1, x2);
pSetF = AddPoints(pSetF, pSetFTmp);
}
pSetF = GetExtremePoints(pSetF, 1);
OPoints.insert(make_pair(OPoints.size(),pSetF));
map<int,vector<gp_Pnt>>::iterator it;
it=OPoints.begin();
int i = 0;
int j=0;
int cnt=0;
while(it!=OPoints.end()){
for (j=0;j<it->second.size();j++)
{
if(it->second[j].Y() < 0)
{
continue;
}
pnts[cnt].X= it->second[j].X();
pnts[cnt].Y = it->second[j].Y();
pnts[cnt++].Z = it->second[j].Z();
break;
}
//cnt = cnt+j;
//lens[i] = j;
i++;
it++;
}
lens[0] = OPoints.size();
return 0;
}
//int OffsetGenerate1::GetMarginLineleData(int lens[], OffsetTablePoint *pnts)
//{
// TopoDS_Shape TopoShape,sshape1,sshape2, topoSolid;
// //GetHalfShell();
// if(dataMD.m_mapMainDeckSurf.size()==1)
// sshape1=dataMD.m_mapAllTopoShapes.find(dataMD.m_mapMainDeckSurf.begin()->first)->second;
// else
// return -1; //Volume;
// if(dataMD.m_mapShellSurf.size()==1)
// sshape2=dataMD.m_mapAllTopoShapes.find(dataMD.m_mapShellSurf.begin()->first)->second;
// else
// return -1; //Volume;
//
// //gp_Trsf theTransformation;
// //theTransformation.SetTranslation(gp_Vec(0,0,-0.076));
// //sshape1= BRepBuilderAPI_Transform(sshape1, theTransformation, false);
//
// vector<TopoDS_Edge> edges = GetSectionEdges(sshape1, sshape2);
// Bnd_Box box;
// double x1,x2,y1,y2,z1,z2;
// for(vector<TopoDS_Edge>::iterator iter = edges.begin(); iter != edges.end(); iter++)
// {
// TopoDS_Edge edge = TopoDS::Edge(*iter);
// BRepBndLib::Add(edge, box);
// }
// box.SetGap(0.0);
// box.Get(x1,y1,z1,x2,y2,z2);
// //-----------------------------------------------------------------------------------------------------------------------------
// //艉端点
// vector<gp_Pnt> pSetD;
// TopoDS_Face fd = CreateFace(-1, x1);
// for(vector<TopoDS_Edge>::iterator iter = edges.begin(); iter != edges.end(); iter++)
// {
// TopoDS_Edge edge = TopoDS::Edge(*iter);
// vector<gp_Pnt> pSetDTmp = GetSectionPoints1(edge, fd);
// //pSetDTmp = CleanPoints(pSetDTmp, -1, x2);
// pSetD = AddPoints(pSetD, pSetDTmp);
// }
// pSetD = GetExtremePoints(pSetD, -1);
// double xD = 10000,zD = 0;
// for(int i = 0; i < pSetD.size(); i++)
// {
// if(xD > pSetD[i].X())
// {
// xD = pSetD[i].X();
// zD = pSetD[i].Z();
// }
// }
// fd = CreateFace(-3, zD - 0.076);
// pSetD.clear();
// vector<TopoDS_Edge> edgesD = GetSectionEdges(sshape2, fd);
// for(vector<TopoDS_Edge>::iterator iter = edgesD.begin(); iter != edgesD.end(); iter++)
// {
// TopoDS_Edge edge = TopoDS::Edge(*iter);
// vector<gp_Pnt> pSetDTmp = GetSectionPoints1(edge, fd);
// //pSetDTmp = CleanPoints(pSetDTmp, -1, x2);
// pSetD = AddPoints(pSetD, pSetDTmp);
// }
// pSetD = GetExtremePoints(pSetD, -1);
// OPoints.insert(make_pair(OPoints.size(),pSetD));
// //------------------------------------------------------------------------------------------------------
// //站
// int count = 0;
// for(int i = 0; i < dataMD.m_mapStation.size(); i++)
// {
// double x = dataMD.m_mapStation[i];
// vector<gp_Pnt> pSet;
// TopoDS_Face f = CreateFace(-1, x);
// vector<TopoDS_Edge> edgesS = GetSectionEdges(sshape2, f);
// if(edgesS.size() > 0)
// {
// Bnd_Box boxS;
// double xS1,xS2,yS1,yS2,zS1,zS2;
// for(vector<TopoDS_Edge>::iterator iter = edgesS.begin(); iter != edgesS.end(); iter++)
// {
// TopoDS_Edge edge = TopoDS::Edge(*iter);
// BRepBndLib::Add(edge, boxS);
// }
// boxS.SetGap(0.0);
// boxS.Get(xS1,yS1,zS1,xS2,yS2,zS2);
// f = CreateFace(-3, zS2- 0.076);
//
// for(vector<TopoDS_Edge>::iterator iter = edgesS.begin(); iter != edgesS.end(); iter++)
// {
// TopoDS_Edge edge = TopoDS::Edge(*iter);
// vector<gp_Pnt> pSetTmp = GetSectionPoints(edge, f);
// pSetTmp = CleanPoints(pSetTmp, -1, x);
// pSet = AddPoints(pSet, pSetTmp);
// count++;
// }
// }
// OPoints.insert(make_pair(OPoints.size(),pSet));
// }
// //----------------------------------------------------------------------------------------------
// //艏端点
// vector<gp_Pnt> pSetF;
// TopoDS_Face ff = CreateFace(-1, x2);
// for(vector<TopoDS_Edge>::iterator iter = edges.begin(); iter != edges.end(); iter++)
// {
// TopoDS_Edge edge = TopoDS::Edge(*iter);
// vector<gp_Pnt> pSetFTmp = GetSectionPoints1(edge, ff);
// //pSetFTmp = CleanPoints(pSetFTmp, -1, x1);
// pSetF = AddPoints(pSetF, pSetFTmp);
// }
// pSetF = GetExtremePoints(pSetF, 1);
//
// double xF = -10000,zF = 0;
// for(int i = 0; i < pSetF.size(); i++)
// {
// if(xF < pSetF[i].X())
// {
// xF = pSetF[i].X();
// zF = pSetF[i].Z();
// }
// }
// ff = CreateFace(-3, zF - 0.076);
// pSetF.clear();
// vector<TopoDS_Edge> edgesF = GetSectionEdges(sshape2, ff);
// for(vector<TopoDS_Edge>::iterator iter = edgesF.begin(); iter != edgesF.end(); iter++)
// {
// TopoDS_Edge edge = TopoDS::Edge(*iter);
// vector<gp_Pnt> pSetFTmp = GetSectionPoints1(edge, ff);
// //pSetDTmp = CleanPoints(pSetDTmp, -1, x2);
// pSetF = AddPoints(pSetF, pSetFTmp);
// }
// pSetF = GetExtremePoints(pSetF, 1);
// OPoints.insert(make_pair(OPoints.size(),pSetF));
//
// map<int,vector<gp_Pnt>>::iterator it;
// it=OPoints.begin();
//
// int i = 0;
// int j=0;
// int cnt=0;
// while(it!=OPoints.end()){
// for (j=0;j<it->second.size();j++)
// {
// if(it->second[j].Y() < 0)
// {
// continue;
// }
// pnts[cnt].X= it->second[j].X();
// pnts[cnt].Y = it->second[j].Y();
// pnts[cnt++].Z = it->second[j].Z();
// break;
// }
// //cnt = cnt+j;
// //lens[i] = j;
// i++;
// it++;
// }
// lens[0] = OPoints.size();
// return 0;
//}