C++ YsShellExt::Conv方法代码示例

void YsShellExt_SewingInfo::MakeEdgeMidVertexInfo(const YsShellExt &shl)
{
	edgeMidVtx.CleanUp();
	edgeMidVtx.SetShell(shl.Conv());
	for(auto &vone : vtxOnEdge)
	{
		YsShell_LocalOperation::EdgeMidVertex *midVtx=edgeMidVtx.FindAttrib(vone.edVtHd[0],vone.edVtHd[1]);
		if(NULL==midVtx)
		{
			YsShell_LocalOperation::EdgeMidVertex newEdgeMidVtx;
			newEdgeMidVtx.edge[0]=vone.edVtHd[0];
			newEdgeMidVtx.edge[1]=vone.edVtHd[1];
			newEdgeMidVtx.midVtHd.MakeUnitLength(vone.createdVtHd);
			edgeMidVtx.SetAttrib(vone.edVtHd,newEdgeMidVtx);
		}
		else
		{
			midVtx->midVtHd.Append(vone.createdVtHd);
		}
	}

	for(auto hd : edgeMidVtx.AllHandle())
	{
		auto &edgVtxInfo=edgeMidVtx.GetAttrib(hd);
		if(1<edgVtxInfo.midVtHd.GetN())
		{
			YsArray <double> dist(edgVtxInfo.midVtHd.GetN(),NULL);
			for(YSSIZE_T idx=0; idx<edgVtxInfo.midVtHd.GetN(); ++idx)
			{
				dist[idx]=shl.GetEdgeLength(edgVtxInfo.edge[0],edgVtxInfo.midVtHd[idx]);
			}
			YsQuickSort(dist.GetN(),dist.GetEditableArray(),edgVtxInfo.midVtHd.GetEditableArray());
		}
	}
}

YSRESULT YsShellExt_RoundUtil3d::SetUpForVertexSequenceAndPolygonArray(
    const YsShellExt &shl,
    const YsArray <YsArray <YsShellVertexHandle> > &allBoundary,
    const YsArray <YsShellPolygonHandle> &sideAPolygonArray,
    const YsArray <YsShellPolygonHandle> &sideBPolygonArray)
{
	YsHashTable <YSSIZE_T> vtKeyToBoundaryIdx;
	YsShellEdgeStore boundaryEdge((const YsShell &)shl);
	for(auto idx : allBoundary.AllIndex())
	{
		YsArray <YsShellVertexHandle> contourVtHd=allBoundary[idx];

		for(YSSIZE_T vtIdx=0; vtIdx<contourVtHd.GetN()-1; ++vtIdx)
		{
			if(YSTRUE!=boundaryEdge.IsIncluded(contourVtHd[vtIdx],contourVtHd[vtIdx+1]))
			{
				boundaryEdge.AddEdge(contourVtHd[vtIdx],contourVtHd[vtIdx+1]);
				roundEdgeArray.Increment();
				roundEdgeArray.Last().Initialize();
				roundEdgeArray.Last().edVtHd[0]=contourVtHd[vtIdx];
				roundEdgeArray.Last().edVtHd[1]=contourVtHd[vtIdx+1];
			}
		}
		for(auto vtHd : contourVtHd)
		{
			vtKeyToBoundaryIdx.AddElement(shl.GetSearchKey(vtHd),idx);
		}
	}

	// Boundary edge hash and sideBPolygon store have been constructed.
	YsShellExt_OffsetUtil2d &sideAOffset=offsetUtil[0],&sideBOffset=offsetUtil[1];

	YsShellPolygonStore sideAPolygon((const YsShell &)shl),sideBPolygon((const YsShell &)shl);
	sideAPolygon.AddPolygon(sideAPolygonArray);
	sideBPolygon.AddPolygon(sideBPolygonArray);



	YSBOOL sideAOffsetNecessary=YSFALSE,sideBOffsetNecessary=YSFALSE;
	if(YSTRUE==alwaysUseOffset)
	{
		sideAOffsetNecessary=YSTRUE;
		sideBOffsetNecessary=YSTRUE;
	}
	else
	{
		for(auto boundary : allBoundary)
		{
			YsArray <YsShellVertexHandle> contourVtHd=boundary;

			for(auto vtHd : contourVtHd)
			{
				YsArray <YsShellVertexHandle,16> connVtHdArray;
				shl.GetConnectedVertex(connVtHdArray,vtHd);

				YSBOOL sideAEdgePresent=YSFALSE,sideBEdgePresent=YSFALSE;
				for(auto connVtHd : connVtHdArray)
				{
					if(YSTRUE==boundaryEdge.IsIncluded(vtHd,connVtHd))
					{
						continue;
					}

					if(YSTRUE==IsEdgeUsing(vtHd,connVtHd,shl.Conv(),sideAPolygon))
					{
						sideAEdgePresent=YSTRUE;
					}
					else if(YSTRUE==IsEdgeUsing(vtHd,connVtHd,shl.Conv(),sideBPolygon))
					{
						sideBEdgePresent=YSTRUE;
					}
				}
				if(YSTRUE!=sideAEdgePresent)
				{
					sideAOffsetNecessary=YSTRUE;
				}
				if(YSTRUE!=sideBEdgePresent)
				{
					sideBOffsetNecessary=YSTRUE;
				}
			}
		}
	}

	printf("%s %d\n",__FUNCTION__,__LINE__);
	printf("%d %d\n",sideAOffsetNecessary,sideBOffsetNecessary);

	if(YSTRUE==sideAOffsetNecessary)
	{
		if(YSOK!=sideAOffset.SetUpForOneSideOfVertexSequence(shl,allBoundary,sideAPolygonArray))
		{
			return YSERR;
		}
		for(YSSIZE_T idx=0; idx<sideAOffset.newVtxArray.GetN(); ++idx)
		{
			auto newVtx=sideAOffset.newVtxArray[idx];
			cornerArray.Increment();
			cornerArray.Last().Initialize();
			cornerArray.Last().fromVtHd=newVtx.fromVtHd;
			cornerArray.Last().toVtHd=NULL;
//.........这里部分代码省略.........

void YsShellExt_SewingInfo::MakePolygonSplitInfo(const YsShellExt &shl)
{
	// A concave polygon may be cut twice by one crawling.
	YsShellPolygonAttribTable <YsArray <YsArray <YsShellVertexHandle,2> > > plHdToDivider(shl.Conv());

	for(auto &v : vtxSequence)
	{
		if(NULL==v.vtHd)
		{
			if(0<=v.vtxOnEdgeIdx)
			{
				v.vtHd=vtxOnEdge[v.vtxOnEdgeIdx].createdVtHd;
			}
			else if(0<=v.vtxOnPlgIdx)
			{
				v.vtHd=vtxOnPlg[v.vtxOnPlgIdx].vtHd;
			}
		}
	}

	{
		YsShellPolygonHandle currentPlHd=NULL;
		YsArray <YsShellVertexHandle,2> currentDivider;
		for(YSSIZE_T idx=0; idx<vtxSequence.GetN(); ++idx)
		{
			if(0==currentDivider.GetN())
			{
				currentPlHd=vtxSequence[idx].plHd;
				currentDivider.Append(vtxSequence[idx].vtHd);
			}
			else
			{
				currentDivider.Append(vtxSequence[idx].vtHd);

				if(idx==vtxSequence.GetN()-1 || vtxSequence[idx].plHd!=currentPlHd)
				{
					if(2<=currentDivider.GetN())
					{
						YsArray <YsArray <YsShellVertexHandle,2> > *pldv=plHdToDivider[currentPlHd];
						if(NULL==pldv)
						{
							YsArray <YsArray <YsShellVertexHandle,2> > newDividerArray(1,NULL);
							newDividerArray[0].MoveFrom(currentDivider);
							plHdToDivider.SetAttrib(currentPlHd,newDividerArray);
						}
						else
						{
							pldv->Append(currentDivider);
						}
					}

					currentDivider.CleanUp();
					currentDivider.Append(vtxSequence[idx].vtHd);
				}

				currentPlHd=vtxSequence[idx].plHd;
			}
		}
	}

	for(auto hashHd : plHdToDivider.AllHandle())
	{
		auto plKey=plHdToDivider.GetKey(hashHd);
		auto plHd=shl.FindPolygon(plKey);
		auto &divider=*plHdToDivider[plHd];

		YsSegmentedArray <YsArray <YsShellVertexHandle,4>,4> plVtHd(1,NULL);
		plVtHd[0]=shl.GetPolygonVertex(plHd);

		for(auto d : divider)
		{
			YsArray <YsShellVertexHandle,4> fragment;
			for(auto &pl : plVtHd)
			{
				if(YSOK==YsShellExt_SplitLoopByHandleAndMidNode(pl,fragment,d))
				{
					plVtHd.Append(fragment);
					break;
				}
			}
		}

		plgSplit.Increment();
		plgSplit.Last().plHd=plHd;
		plgSplit.Last().plVtHdArray=plVtHd;
	}
}

YSRESULT YsShellExt_SewingInfo::CrawlOneSegment(
		YsShellVertexHandle &currentVtHd,
		YsShell::Edge &currentEdge,
		YsShellPolygonHandle &currentPlHd,
		YsVec3 &currentPos,
		const YsShellExt &shl,
		const YsVec3 &goalPos,
		YsShellVertexHandle goalVtHd)
{
	auto startDir=YsUnitVector(goalPos-currentPos);

	YsShellCrawler crawler;
	crawler.crawlingMode=YsShellCrawler::CRAWL_TO_GOAL;
	crawler.goal=goalPos;

	YSRESULT started=YSERR;
	if(NULL!=currentVtHd)
	{
		started=crawler.Start(shl.Conv(),currentPos,startDir,currentVtHd);
	}
	else if(NULL!=currentEdge[0] && NULL!=currentEdge[1])
	{
		started=crawler.Start(shl.Conv(),currentPos,startDir,currentEdge);
	}
	else if(NULL!=currentPlHd)
	{
		started=crawler.Start(shl.Conv(),currentPos,startDir,currentPlHd);
	}

	if(YSOK==started)
	{
		if(0==vtxSequence.GetN())
		{
			vtxSequence.Increment();
			vtxSequence.Last().Initialize();
			vtxSequence.Last().vtHd=currentVtHd;
			vtxSequence.Last().plHd=crawler.currentPlHd;
			vtxSequence.Last().pos=crawler.currentPos;
		}
		else
		{
			vtxSequence.Last().plHd=crawler.currentPlHd;
		}

// Debugging sphere.srf 371 276 375
// [Selected Vertices]
// Vertex Id:     370  Internal Hash Key:     371  Position: -3.467600  -0.689748   3.535534
// Vertex Id:     275  Internal Hash Key:     276  Position: -4.530637  -1.876651   0.975452
// Vertex Id:     374  Internal Hash Key:     375  Position: -1.964237  -2.939689   3.535534


		YSBOOL watch=YSFALSE;
		while(YSOK==crawler.Crawl(shl.Conv(),0.0,watch))
		{
			if((crawler.currentState==YsShellCrawler::STATE_ON_VERTEX || crawler.currentEdVtHd[0]==crawler.currentEdVtHd[1]) &&
			   crawler.currentEdVtHd[0]==vtxSequence.Last().vtHd)
			{
				vtxSequence.Last().plHd=crawler.currentPlHd;
			}
			else
			{
				switch(crawler.currentState)
				{
				case YsShellCrawler::STATE_IN_POLYGON:
					if(crawler.currentPos==goalPos || 
					   ((NULL==goalVtHd || 0==shl.GetNumPolygonUsingVertex(goalVtHd)) && YSTRUE==crawler.reachedDeadEnd)) // Can happen in the end.
					{
						vtxSequence.Increment();
						vtxSequence.Last().Initialize();
						vtxSequence.Last().plHd=crawler.currentPlHd;
						vtxSequence.Last().vtHd=goalVtHd;
						vtxSequence.Last().pos=crawler.currentPos;
						if(NULL==goalVtHd)
						{
							vtxSequence.Last().vtxOnPlgIdx=(int)vtxOnPlg.GetN();
							vtxOnPlg.Increment();
							vtxOnPlg.Last().plHd=crawler.currentPlHd;
							vtxOnPlg.Last().vtHd=goalVtHd;
							vtxOnPlg.Last().pos=goalPos;
						}
					}
					break;
				case YsShellCrawler::STATE_ON_VERTEX:
					vtxSequence.Increment();
					vtxSequence.Last().Initialize();
					vtxSequence.Last().plHd=crawler.currentPlHd;
					vtxSequence.Last().vtHd=crawler.currentEdVtHd[0];
					vtxSequence.Last().pos=crawler.currentPos;
					break;
				case YsShellCrawler::STATE_ON_EDGE:
					if(crawler.currentEdVtHd[0]==crawler.currentEdVtHd[1])
					{
						vtxSequence.Increment();
						vtxSequence.Last().Initialize();
						vtxSequence.Last().plHd=crawler.currentPlHd;
						vtxSequence.Last().vtHd=crawler.currentEdVtHd[0];
						vtxSequence.Last().pos=crawler.currentPos;
					}
					else
					{
//.........这里部分代码省略.........