void exploreUp(void)
{
DLINK2PTR beptr ;
int beg , end , left , rite , finishLine , b , l , r , rec , index ;
for( rec = 1 ; rec <= numRects ; rec++ ) {
beg = rectArray[rec].b ;
end = rectArray[rec].t ;
rite = rectArray[rec].r ;
left = rectArray[rec].l ;
finishLine = 1000000 ;
beptr = BEptrs[ tprop( BEroot , beg ) ] ;
for( ; beptr != (DLINK2PTR) NULL; beptr = beptr->next ){
index = beptr->index ;
b = rectArray[index].b ;
if( b > finishLine ) {
break ;
}
l = rectArray[index].l ;
r = rectArray[index].r ;
if( b <= end || l > rite || r < left ) {
continue ;
}
if( constructVedge( rec , index ) ) {
break ;
}
finishLine = rectArray[index].t ;
}
}
return ;
}
void exploreRite(void)
{
DLINK2PTR leptr ;
int beg , end , top , bot , finishLine , l , b , t , rec , index ;
for( rec = 1 ; rec <= numRects ; rec++ ) {
beg = rectArray[rec].l ;
end = rectArray[rec].r ;
top = rectArray[rec].t ;
bot = rectArray[rec].b ;
finishLine = 1000000 ;
leptr = LEptrs[ tprop( LEroot , beg ) ] ;
for( ; leptr != (DLINK2PTR) NULL; leptr = leptr->next ){
index = leptr->index ;
l = rectArray[index].l ;
if( l > finishLine ) {
break ;
}
b = rectArray[index].b ;
t = rectArray[index].t ;
if( l <= end || b > top || t < bot ) {
continue ;
}
if( constructHedge( rec , index ) ) {
break ;
}
finishLine = rectArray[index].r ;
}
}
return ;
}
int constructHedge( int index1 , int index2 )
{
DLINK1PTR h1ptr , h2ptr , hptr ;
int b1 , b2 , t1 , t2 , b , l , r , t , edge1 , edge2 , eb , et ;
int el , er , el1 , er1 , el2 , er2 ;
int edge , x ;
b1 = rectArray[index1].b ;
t1 = rectArray[index1].t ;
b2 = rectArray[index2].b ;
t2 = rectArray[index2].t ;
b = ( b1 >= b2 ) ? b1 : b2 ;
t = ( t1 <= t2 ) ? t1 : t2 ;
l = rectArray[index1].r ;
r = rectArray[index2].l ;
eb = -1000000 ;
h1ptr = HRptrs[ tprop( HRroot , b ) ] ;
for( ; h1ptr != (DLINK1PTR) NULL; h1ptr = h1ptr->next ) {
edge1 = h1ptr->edge ;
if( edgeList[edge1].loc > t ) {
break ;
}
if( edgeList[edge1].UorR < 0 ) {
continue ;
}
if( edgeList[edge1].start > l || edgeList[edge1].end < r ) {
continue ;
}
eb = edgeList[edge1].loc ;
hptr = h1ptr ;
}
if( eb == -1000000 ) {
return(0) ;
}
h2ptr = Hptrs[ tprop( Hroot , eb ) ] ;
for( ; h2ptr != (DLINK1PTR) NULL; h2ptr = h2ptr->next ) {
edge2 = h2ptr->edge ;
if( edgeList[edge2].UorR > 0 ) {
continue ;
}
if( edgeList[edge2].start > l || edgeList[edge2].end < r ) {
continue ;
}
et = edgeList[edge2].loc ;
break ;
}
if( et > t ) {
return(0) ;
}
h1ptr = hptr ;
edge1 = h1ptr->edge ;
er1 = edgeList[edge1].end ;
el1 = edgeList[edge1].start ;
er2 = edgeList[edge2].end ;
el2 = edgeList[edge2].start ;
if( edgeList[edge1].fixed == 1 && edgeList[edge2].fixed == 1 ) {
if( edgeList[edge1].cell > 0 && edgeList[edge2].cell > 0 ) {
er = (er1 >= er2) ? er1 : er2 ;
el = (el1 <= el2) ? el1 : el2 ;
} else if( edgeList[edge1].cell > 0 ) {
er = er1 ;
el = el1 ;
} else if( edgeList[edge2].cell > 0 ) {
er = er2 ;
el = el2 ;
} else {
er = 1000000 ;
el = -1000000 ;
}
} else if( edgeList[edge1].fixed == 1 ) {
if( edgeList[edge1].cell > 0 ) {
er = er1 ;
el = el1 ;
} else {
er = 1000000 ;
el = -1000000 ;
}
} else if( edgeList[edge2].fixed == 1 ) {
if( edgeList[edge2].cell > 0 ) {
er = er2 ;
el = el2 ;
} else {
er = 1000000 ;
el = -1000000 ;
}
} else {
er = 1000000 ;
el = -1000000 ;
}
if( ! ( er > rectArray[index2].r ) ){
if( rectArray[index2].xc < er ) {
rectArray[index2].xc = er ;
rectArray[index2].xreset = 2 ;
}
}
if( ! ( el < rectArray[index1].l ) ){
if( rectArray[index1].xc > el ) {
rectArray[index1].xc = el ;
rectArray[index1].xreset = 1 ;
}
}
if( rectArray[index1].yc < eb || rectArray[index1].yc > et ) {
rectArray[index1].yc = (eb + et) / 2 ;
}
if( rectArray[index2].yc < eb || rectArray[index2].yc > et ) {
rectArray[index2].yc = (eb + et) / 2 ;
}
if( edgeList[edge1].fixed == 0 ) {
hptr = Hptrs[ tprop( Hroot , eb ) ] ;
x = edgeList[hptr->edge].loc ;
hptr = hptr->next ;
for( ; hptr != (DLINK1PTR) NULL; hptr = hptr->next ) {
if( edgeList[hptr->edge].loc > x ) {
break ;
}
}
for( hptr = hptr->prev; hptr != (DLINK1PTR) NULL;
hptr = hptr->prev ) {
if( hptr == h2ptr ) {
continue ;
}
edge = hptr->edge ;
if( edgeList[edge].UorR > 0 ) {
continue ;
}
if( edgeList[edge].start > l || edgeList[edge].end < r ) {
continue ;
}
break ;
}
eb -= (eb - edgeList[edge].loc) - (eb - edgeList[edge].loc) / 2 ;
}
if( edgeList[edge2].fixed == 0 ) {
hptr = Hptrs[ tprop( Hroot , et ) ] ;
for(; hptr != (DLINK1PTR) NULL; hptr = hptr->next ) {
if( hptr == h1ptr ) {
continue ;
}
edge = hptr->edge ;
if( edgeList[edge].UorR < 0 ) {
continue ;
}
if( edgeList[edge].start > l || edgeList[edge].end < r ) {
continue ;
}
break ;
}
et += (edgeList[edge].loc - et) / 2 ;
}
if( ++eNum % 100 == 0 ) {
eArray = (EBOXPTR) realloc( eArray, (eNum + 100) * sizeof(EBOX));
}
eArray[eNum].index1 = index1 ;
eArray[eNum].index2 = index2 ;
eArray[eNum].width = et - eb ;
eArray[eNum].lbside = eb ;
eArray[eNum].rtside = et ;
eArray[eNum].edge1 = edge1 ;
eArray[eNum].edge2 = edge2 ;
return(1) ;
}
int constructVedge( int index1 , int index2 )
{
DLINK1PTR v1ptr , v2ptr , vptr ;
int l1 , l2 , r1 , r2 , l , r , b , t , edge1 , edge2 , el , er ;
int eb , et , eb1 , et1 , eb2 , et2 ;
int edge , x ;
l1 = rectArray[index1].l ;
r1 = rectArray[index1].r ;
l2 = rectArray[index2].l ;
r2 = rectArray[index2].r ;
l = ( l1 >= l2 ) ? l1 : l2 ;
r = ( r1 <= r2 ) ? r1 : r2 ;
b = rectArray[index1].t ;
t = rectArray[index2].b ;
el = -1000000 ;
v1ptr = VDptrs[ tprop( VDroot , l ) ] ;
for( ; v1ptr != (DLINK1PTR) NULL; v1ptr = v1ptr->next ) {
edge1 = v1ptr->edge ;
if( edgeList[edge1].loc > r ) {
break ;
}
if( edgeList[edge1].UorR > 0 ) {
continue ;
}
if( edgeList[edge1].start > b || edgeList[edge1].end < t ) {
continue ;
}
el = edgeList[edge1].loc ;
vptr = v1ptr ;
}
if( el == -1000000 ) {
return(0) ;
}
v2ptr = Vptrs[ tprop( Vroot , el ) ] ;
for( ; v2ptr != (DLINK1PTR) NULL; v2ptr = v2ptr->next ) {
edge2 = v2ptr->edge ;
if( edgeList[edge2].UorR < 0 ) {
continue ;
}
if( edgeList[edge2].start > b || edgeList[edge2].end < t ) {
continue ;
}
er = edgeList[edge2].loc ;
break ;
}
if( er > r ) {
return(0) ;
}
v1ptr = vptr ;
edge1 = v1ptr->edge ;
et1 = edgeList[edge1].end ;
eb1 = edgeList[edge1].start ;
et2 = edgeList[edge2].end ;
eb2 = edgeList[edge2].start ;
if( edgeList[edge1].fixed == 1 && edgeList[edge2].fixed == 1 ) {
if( edgeList[edge1].cell > 0 && edgeList[edge2].cell > 0 ) {
et = (et1 >= et2) ? et1 : et2 ;
eb = (eb1 <= eb2) ? eb1 : eb2 ;
} else if( edgeList[edge1].cell > 0 ) {
et = et1 ;
eb = eb1 ;
} else if( edgeList[edge2].cell > 0 ) {
et = et2 ;
eb = eb2 ;
} else {
et = 1000000 ;
eb = -1000000 ;
}
} else if( edgeList[edge1].fixed == 1 ) {
if( edgeList[edge1].cell > 0 ) {
et = et1 ;
eb = eb1 ;
} else {
et = 1000000 ;
eb = -1000000 ;
}
} else if( edgeList[edge2].fixed == 1 ) {
if( edgeList[edge2].cell > 0 ) {
et = et2 ;
eb = eb2 ;
} else {
et = 1000000 ;
eb = -1000000 ;
}
} else {
et = 1000000 ;
eb = -1000000 ;
}
if( ! ( et > rectArray[index2].t ) ){
if( rectArray[index2].yc < et ) {
rectArray[index2].yc = et ;
rectArray[index2].yreset = 2 ;
}
}
if( ! ( eb < rectArray[index1].b ) ){
if( rectArray[index1].yc > eb ) {
rectArray[index1].yc = eb ;
rectArray[index1].yreset = 1 ;
}
}
if( rectArray[index1].xc < el || rectArray[index1].xc > er ) {
rectArray[index1].xc = (el + er) / 2 ;
}
if( rectArray[index2].xc < el || rectArray[index2].xc > er ) {
rectArray[index2].xc = (el + er) / 2 ;
}
if( edgeList[edge1].fixed == 0 ) {
vptr = Vptrs[ tprop( Vroot , el ) ] ;
x = edgeList[vptr->edge].loc ;
vptr = vptr->next ;
for( ; vptr != (DLINK1PTR) NULL; vptr = vptr->next ) {
if( edgeList[vptr->edge].loc > x ) {
break ;
}
}
for( vptr = vptr->prev; vptr != (DLINK1PTR) NULL;
vptr = vptr->prev ) {
if( vptr == v2ptr ) {
continue ;
}
edge = vptr->edge ;
if( edgeList[edge].UorR < 0 ) {
continue ;
}
if( edgeList[edge].start > b || edgeList[edge].end < t ) {
continue ;
}
break ;
}
el -= (el - edgeList[edge].loc) - (el - edgeList[edge].loc) / 2 ;
}
if( edgeList[edge2].fixed == 0 ) {
vptr = Vptrs[ tprop( Vroot , er ) ] ;
for(; vptr != (DLINK1PTR) NULL; vptr = vptr->next ) {
if( vptr == v1ptr ) {
continue ;
}
edge = vptr->edge ;
if( edgeList[edge].UorR > 0 ) {
continue ;
}
if( edgeList[edge].start > b || edgeList[edge].end < t ) {
continue ;
}
break ;
}
er += (edgeList[edge].loc - er) / 2 ;
}
if( ++eNum % 100 == 0 ) {
eArray = (EBOXPTR) realloc( eArray, (eNum + 100) * sizeof(EBOX));
}
eArray[eNum].index1 = index1 ;
eArray[eNum].index2 = index2 ;
eArray[eNum].width = er - el ;
eArray[eNum].lbside = el ;
eArray[eNum].rtside = er ;
eArray[eNum].edge1 = edge1 ;
eArray[eNum].edge2 = edge2 ;
return(1) ;
}
vprobes()
{
DLINK1PTR ritePtr , left1ptr , left2ptr , checkPtr , ptr ;
int ry , rx1 , rx2 , redge , dx1 , dx2 , ledge , edge , check ;
int l1x2 , l1x1 , l1y , l2x2 , l2x1 , l2y ;
ritePtr = hFixedListG ;
for( ; ritePtr != (DLINK1PTR) NULL ; ritePtr = ritePtr->next ) {
redge = ritePtr->edge ;
if( edgeListG[redge].UorR < 0 ) {
continue ;
}
ry = edgeListG[redge].loc ;
rx1 = edgeListG[redge].start ;
rx2 = edgeListG[redge].end ;
left1ptr = HptrsG[ tprop( HrootG , ry ) ] ;
for(; left1ptr != (DLINK1PTR)NULL; left1ptr = left1ptr->next){
ledge = left1ptr->edge ;
if( edgeListG[ledge].UorR > 0 ) {
continue ;
}
l1y = edgeListG[ledge].loc ;
l1x1 = edgeListG[ledge].start ;
l1x2 = edgeListG[ledge].end ;
if( l1x2 <= rx1 || l1x1 > rx1 ) {
continue ;
}
break ;
}
left2ptr = HptrsG[ tprop( HrootG , ry ) ] ;
for(; left2ptr != (DLINK1PTR) NULL ; left2ptr = left2ptr->next){
ledge = left2ptr->edge ;
if( edgeListG[ledge].UorR > 0 ) {
continue ;
}
l2y = edgeListG[ledge].loc ;
l2x1 = edgeListG[ledge].start ;
l2x2 = edgeListG[ledge].end ;
if( l2x2 < rx2 || l2x1 >= rx2 ) {
continue ;
}
break ;
}
if( left1ptr != (DLINK1PTR) NULL && left1ptr == left2ptr ) {
check = 1 ;
checkPtr = HptrsG[ tprop( HrootG , ry ) ] ;
for(; checkPtr != (DLINK1PTR)NULL; checkPtr = checkPtr->next){
if( edgeListG[ checkPtr->edge ].UorR > 0 ) {
continue ;
}
if( edgeListG[ checkPtr->edge ].loc >= l2y ) {
break ;
}
if( edgeListG[ checkPtr->edge ].start >= rx2 ||
edgeListG[ checkPtr->edge ].end <= rx1 ) {
continue ;
}
check = 0 ;
break ;
}
if( check ) {
edgeListG[++numProbesG + edgeCountG].start = ry ;
edgeListG[numProbesG + edgeCountG].end = l2y ;
edgeListG[numProbesG + edgeCountG].loc = rx1 ;
edgeListG[numProbesG + edgeCountG].length = l2y - ry ;
edgeListG[numProbesG + edgeCountG].fixed = 0 ;
edgeListG[numProbesG + edgeCountG].cell = 0 ;
edgeListG[numProbesG + edgeCountG].UorR = 1 ;
tinsert( &vEdgeRootG, rx1 , numProbesG + edgeCountG ) ;
#ifdef DEBUG
fprintf(fpdebugG,"vprobe:%d ", numProbesG ) ;
fprintf(fpdebugG,"start:%d end:%d loc:%d UorR:%d\n",
ry , l2y , rx1 , 1 ) ;
#endif
edgeListG[++numProbesG + edgeCountG].start = ry ;
edgeListG[numProbesG + edgeCountG].end = l2y ;
edgeListG[numProbesG + edgeCountG].loc = rx2 ;
edgeListG[numProbesG + edgeCountG].length = l2y - ry ;
edgeListG[numProbesG + edgeCountG].fixed = 0 ;
edgeListG[numProbesG + edgeCountG].cell = 0 ;
edgeListG[numProbesG + edgeCountG].UorR = -1 ;
tinsert( &vEdgeRootG, rx2 , numProbesG + edgeCountG ) ;
#ifdef DEBUG
fprintf(fpdebugG,"vprobe:%d ", numProbesG ) ;
fprintf(fpdebugG,"start:%d end:%d loc:%d UorR:%d\n",
ry , l2y , rx2 , -1 ) ;
#endif
} else {
doubleDown( ritePtr ) ;
}
continue ;
}
if( left1ptr != (DLINK1PTR) NULL ) {
ptr = HptrsG[ tprop( HrootG , l1y ) ] ;
for( ptr = ptr->next; ptr != (DLINK1PTR) NULL; ptr = ptr->next){
if( edgeListG[ptr->edge].loc > l1y ) {
break ;
}
}
if( ptr == (DLINK1PTR) NULL ) {
ptr = hFixedEndG ;
} else {
ptr = ptr->prev ;
}
for( ; ptr != (DLINK1PTR) NULL; ptr = ptr->prev){
edge = ptr->edge ;
if( edgeListG[edge].UorR < 0 ) {
continue ;
}
dx1 = edgeListG[edge].start ;
dx2 = edgeListG[edge].end ;
if( dx2 < l1x2 || dx1 >= l1x2 ) {
continue ;
}
break ;
}
if( ritePtr == ptr ) {
check = 1 ;
checkPtr = HptrsG[ tprop( HrootG , ry ) ] ;
for(; checkPtr != (DLINK1PTR) NULL ;
checkPtr = checkPtr->next ) {
if( edgeListG[ checkPtr->edge ].UorR > 0 ) {
continue ;
}
if( edgeListG[ checkPtr->edge ].loc >= l1y ) {
break ;
}
if( edgeListG[ checkPtr->edge ].start >= l1x2 ||
edgeListG[ checkPtr->edge ].end <= rx1 ) {
continue ;
}
check = 0 ;
break ;
}
if( check ) {
edgeListG[++numProbesG + edgeCountG].start = ry ;
edgeListG[numProbesG + edgeCountG].end = l1y ;
edgeListG[numProbesG + edgeCountG].loc = rx1 ;
edgeListG[numProbesG + edgeCountG].length = l1y - ry ;
edgeListG[numProbesG + edgeCountG].fixed = 0 ;
edgeListG[numProbesG + edgeCountG].cell = 0 ;
edgeListG[numProbesG + edgeCountG].UorR = 1 ;
tinsert( &vEdgeRootG, rx1 , numProbesG + edgeCountG ) ;
#ifdef DEBUG
fprintf(fpdebugG,"vprobe:%d ", numProbesG ) ;
fprintf(fpdebugG,"start:%d end:%d loc:%d UorR:%d\n",
ry , l1y , rx1 , 1 ) ;
#endif
edgeListG[++numProbesG + edgeCountG].start = ry ;
edgeListG[numProbesG + edgeCountG].end = l1y ;
edgeListG[numProbesG + edgeCountG].loc = l1x2 ;
edgeListG[numProbesG + edgeCountG].length = l1y - ry ;
edgeListG[numProbesG + edgeCountG].fixed = 0 ;
edgeListG[numProbesG + edgeCountG].cell = 0 ;
edgeListG[numProbesG + edgeCountG].UorR = -1 ;
tinsert( &vEdgeRootG, l1x2 , numProbesG + edgeCountG ) ;
#ifdef DEBUG
fprintf(fpdebugG,"vprobe:%d ", numProbesG ) ;
fprintf(fpdebugG,"start:%d end:%d loc:%d UorR:%d\n",
ry , l1y , l1x2 , -1 ) ;
#endif
}
}
}
if( left2ptr != (DLINK1PTR) NULL ) {
ptr = HptrsG[ tprop( HrootG , l2y ) ] ;
for( ptr = ptr->next; ptr != (DLINK1PTR) NULL; ptr = ptr->next){
if( edgeListG[ptr->edge].loc > l2y ) {
break ;
}
}
if( ptr == (DLINK1PTR) NULL ) {
ptr = hFixedEndG ;
} else {
ptr = ptr->prev ;
}
for( ; ptr != (DLINK1PTR) NULL; ptr = ptr->prev){
edge = ptr->edge ;
if( edgeListG[edge].UorR < 0 ) {
continue ;
}
dx1 = edgeListG[edge].start ;
dx2 = edgeListG[edge].end ;
if( dx2 <= l2x1 || dx1 > l2x1 ) {
continue ;
}
break ;
}
if( ritePtr == ptr ) {
check = 1 ;
checkPtr = HptrsG[ tprop( HrootG , ry ) ] ;
for(; checkPtr != (DLINK1PTR) NULL ;
checkPtr = checkPtr->next ) {
if( edgeListG[ checkPtr->edge ].UorR > 0 ) {
continue ;
}
if( edgeListG[ checkPtr->edge ].loc >= l2y ) {
break ;
}
if( edgeListG[ checkPtr->edge ].start >= rx2 ||
edgeListG[ checkPtr->edge ].end <= l2x1 ) {
continue ;
}
check = 0 ;
break ;
}
if( check ) {
edgeListG[++numProbesG + edgeCountG].start = ry ;
edgeListG[numProbesG + edgeCountG].end = l2y ;
edgeListG[numProbesG + edgeCountG].loc = l2x1 ;
edgeListG[numProbesG + edgeCountG].length = l2y - ry ;
edgeListG[numProbesG + edgeCountG].fixed = 0 ;
edgeListG[numProbesG + edgeCountG].cell = 0 ;
edgeListG[numProbesG + edgeCountG].UorR = 1 ;
tinsert( &vEdgeRootG, l2x1 , numProbesG + edgeCountG ) ;
#ifdef DEBUG
fprintf(fpdebugG,"vprobe:%d ", numProbesG ) ;
fprintf(fpdebugG,"start:%d end:%d loc:%d UorR:%d\n",
ry , l2y , l2x1 , 1 ) ;
#endif
edgeListG[++numProbesG + edgeCountG].start = ry ;
edgeListG[numProbesG + edgeCountG].end = l2y ;
edgeListG[numProbesG + edgeCountG].loc = rx2 ;
edgeListG[numProbesG + edgeCountG].length = l2y - ry ;
edgeListG[numProbesG + edgeCountG].fixed = 0 ;
edgeListG[numProbesG + edgeCountG].cell = 0 ;
edgeListG[numProbesG + edgeCountG].UorR = -1 ;
tinsert( &vEdgeRootG, rx2 , numProbesG + edgeCountG ) ;
#ifdef DEBUG
fprintf(fpdebugG,"vprobe:%d ", numProbesG ) ;
fprintf(fpdebugG,"start:%d end:%d loc:%d UorR:%d\n",
ry , l2y , rx2 , -1 ) ;
#endif
}
}
}
doubleDown( ritePtr ) ;
}
return ;
}
