YsArray <YsShellExt_SweepInfoMultiStep::Quad> YsShellExt_SweepInfoMultiStep::MakeSideFaceAndFirstToLastVertexMapping(const YsShellExt &shl)
{
YsShellExt_Mapping <YsShellVertexHandle,YsShellVertexHandle>::CleanUp();
YsArray <Quad> quadArray;
for(YSSIZE_T edIdx=0; edIdx<=srcEdVtHd.GetN()-2; edIdx+=2)
{
YSSIZE_T idxInLayer[2];
if(YSOK==srcVtKeyToMidPointIndex.FindElement(idxInLayer[0],shl.GetSearchKey(srcEdVtHd[edIdx])) &&
YSOK==srcVtKeyToMidPointIndex.FindElement(idxInLayer[1],shl.GetSearchKey(srcEdVtHd[edIdx+1])))
{
YsShellVertexHandle curEdVtHd[2]={srcEdVtHd[edIdx],srcEdVtHd[edIdx+1]};
for(auto &layer : layerArray)
{
YsShellVertexHandle nxtEdVtHd[2]={layer.pointArray[idxInLayer[0]].vtHd,layer.pointArray[idxInLayer[1]].vtHd};
quadArray.Increment();
quadArray.Last().quadVtHd[0]=curEdVtHd[1];
quadArray.Last().quadVtHd[1]=curEdVtHd[0];
quadArray.Last().quadVtHd[2]=nxtEdVtHd[0];
quadArray.Last().quadVtHd[3]=nxtEdVtHd[1];
curEdVtHd[0]=nxtEdVtHd[0];
curEdVtHd[1]=nxtEdVtHd[1];
}
if(YSTRUE!=YsShellExt_VertexToVertexMapping::CheckMappingExist(shl,srcEdVtHd[edIdx]))
{
YsShellExt_VertexToVertexMapping::AddMapping(shl,srcEdVtHd[edIdx], curEdVtHd[0]);
}
if(YSTRUE!=YsShellExt_VertexToVertexMapping::CheckMappingExist(shl,srcEdVtHd[edIdx+1]))
{
YsShellExt_VertexToVertexMapping::AddMapping(shl,srcEdVtHd[edIdx+1],curEdVtHd[1]);
}
}
}
return quadArray;
}
void YsShellExt_PatchBetweenTwoConstEdge::MinimizeDihedralAngleSum(void)
{
YsArray <YsStaticArray <YsShellVertexHandle,2> > allEdge;
YsShellEdgeEnumHandle edHd=NULL;
while(YSOK==shl.MoveToNextEdge(edHd))
{
YsShellVertexHandle edVtHd[2];
shl.GetEdge(edVtHd,edHd);
if(0==shl.GetNumConstEdgeUsingEdgePiece(edVtHd))
{
allEdge.Increment();
allEdge.Last()[0]=edVtHd[0];
allEdge.Last()[1]=edVtHd[1];
}
}
for(;;)
{
YSBOOL improvement=YSFALSE;
for(auto &edVtHd : allEdge)
{
printf("%s %d\n",__FUNCTION__,__LINE__);
YsVec3 edVtPos[2]={shl.GetVertexPosition(edVtHd[0]),shl.GetVertexPosition(edVtHd[1])};
printf("%s %s\n",edVtPos[0].Txt(),edVtPos[1].Txt());
YsShell_SwapInfo swapInfo;
if(YSOK==swapInfo.MakeInfo((const YsShell &)shl,edVtHd))
{
printf("%s %d\n",__FUNCTION__,__LINE__);
if(0<shl.GetNumPolygonUsingEdge(swapInfo.newDiagonal[0],swapInfo.newDiagonal[1]))
{
printf("%s %d\n",__FUNCTION__,__LINE__);
continue;
}
int seqId[2];
if(YSOK!=patchVtKeyToSeqId.FindElement(seqId[0],shl.GetSearchKey(swapInfo.newDiagonal[0])) ||
YSOK!=patchVtKeyToSeqId.FindElement(seqId[1],shl.GetSearchKey(swapInfo.newDiagonal[1])) ||
seqId[0]==seqId[1])
{
printf("%s %d\n",__FUNCTION__,__LINE__);
continue;
}
const double oldDhaTotal=YsShellExt_CalculateTotalDihedralAngleAroundEdge(shl,swapInfo.orgDiagonal);
YsArray <YsShellVertexHandle,4> oldTriVtHd[2];
shl.GetPolygon(oldTriVtHd[0],swapInfo.triPlHd[0]);
shl.GetPolygon(oldTriVtHd[1],swapInfo.triPlHd[1]);
shl.SetPolygonVertex(swapInfo.triPlHd[0],3,swapInfo.newTriVtHd[0]);
shl.SetPolygonVertex(swapInfo.triPlHd[1],3,swapInfo.newTriVtHd[1]);
const double newDhaTotal=YsShellExt_CalculateTotalDihedralAngleAroundEdge(shl,swapInfo.newDiagonal);
printf("%lf %lf\n",newDhaTotal,oldDhaTotal);
if(newDhaTotal<oldDhaTotal-YsTolerance)
{
printf("%s %d\n",__FUNCTION__,__LINE__);
improvement=YSTRUE;
edVtHd[0]=swapInfo.newDiagonal[0];
edVtHd[1]=swapInfo.newDiagonal[1];
}
else
{
shl.SetPolygonVertex(swapInfo.triPlHd[0],oldTriVtHd[0]);
shl.SetPolygonVertex(swapInfo.triPlHd[1],oldTriVtHd[1]);
}
}
}
if(YSTRUE!=improvement)
{
break;
}
}
}
YsArray <YsShellExt_RoundUtil::VertexPositionPair> YsShellExt_RoundUtil::MakeRoundedVertexSequence(const YsShell &shl,YSSIZE_T nVt,const YsShellVertexHandle vtHdArrayIn[],YSBOOL isLoop) const
{
YsArray <YsShellVertexHandle> orgVtHdArray(nVt,vtHdArrayIn);
YsArray <VertexPositionPair> newVtHdArray;
for(YSSIZE_T orgVtIdx=0; orgVtIdx<orgVtHdArray.GetN(); ++orgVtIdx)
{
YSBOOL rounded=YSFALSE;
for(const auto &roundCorner : cornerArray)
{
if(roundCorner.fromVtHd==orgVtHdArray[orgVtIdx])
{
int forward=0,backward=1;
if(roundCorner.toVtHd[0]==orgVtHdArray.GetCyclic(orgVtIdx-1))
{
forward=1;
backward=0;
}
else if(roundCorner.toVtHd[1]==orgVtHdArray.GetCyclic(orgVtIdx-1))
{
forward=0;
backward=1;
}
else
{
continue;
}
YSBOOL skipFirst=YSFALSE;
if(0<newVtHdArray.GetN() && newVtHdArray.Last().pos==roundCorner.subDiv[backward].Last().pos)
{
skipFirst=YSTRUE;
}
newVtHdArray.Append(roundCorner.subDiv[backward]);
newVtHdArray.Increment();
newVtHdArray.Last().vtHd=orgVtHdArray[orgVtIdx];
newVtHdArray.Last().pos=roundCorner.roundedCornerPos;
for(YSSIZE_T i=roundCorner.subDiv[forward].GetN()-1; 0<=i; --i)
{
if(YSTRUE==skipFirst)
{
skipFirst=YSFALSE;
continue;
}
newVtHdArray.Append(roundCorner.subDiv[forward][i]);
}
rounded=YSTRUE;
}
}
if(YSTRUE!=rounded)
{
newVtHdArray.Increment();
newVtHdArray.Last().vtHd=orgVtHdArray[orgVtIdx];
newVtHdArray.Last().pos=shl.GetVertexPosition(newVtHdArray.Last().vtHd);
}
}
if(2<=newVtHdArray.GetN() && YSTRUE==isLoop && newVtHdArray[0].pos==newVtHdArray.Last().pos)
{
newVtHdArray.DeleteLast();
}
return newVtHdArray;
}
void YsArguments2(YsArray <YsString,16> &args,const char vv[],YSSIZE_T l,const char *blank,const char *comma)
{
YsString empty;
args.Set(0,NULL);
YSSIZE_T i=0;
while(YSTRUE==CharIsOneOf(vv[i],blank))
{
i++;
}
YSSIZE_T head=i;
while(i<l)
{
if(vv[head]=='\"')
{
head++;
i++;
while(i<l && vv[i]!='\"')
{
if(vv[i]&0x80) // 1st letter of Kanji character?
{
i++;
}
else if(isprint(vv[i])==0)
{
break;
}
i++;
}
args.Append(empty);
args[args.GetN()-1].Set(i-head,vv+head);
if(vv[i]=='\"')
{
i++;
}
}
else
{
while(i<l && (CharIsOneOf(vv[i],blank)!=YSTRUE && CharIsOneOf(vv[i],comma)!=YSTRUE))
{
if(vv[i]&0x80) // 1st letter of Kanji character?
{
i++;
}
else if(isprint(vv[i])==0)
{
break;
}
i++;
}
if(head<i) // <- This condition is added on 2005/03/03
{
args.Append(empty);
args[args.GetN()-1].Set(i-head,vv+head);
}
else if(head==i && YSTRUE==CharIsOneOf(vv[i],comma)) // < This condition is added (I thought there was, did I accidentally delet?) on 2012/01/26
{
args.Increment();
args.GetEnd().Set("");
}
}
while(i<l && isprint(vv[i])==0)
{
i++;
}
while(i<l && CharIsOneOf(vv[i],blank)==YSTRUE) // Skip blank separator
{
i++;
}
if(CharIsOneOf(vv[i],comma)==YSTRUE) // Skip one comma separator
{
i++;
while(i<l && CharIsOneOf(vv[i],blank)==YSTRUE) // Skip blank separator after a comma separator
{
i++;
}
if(i==l)
{
args.Append(empty);
}
}
head=i;
}
}
