This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
blender-archive/source/blender/radiosity/intern/source/radnode.c
Hans Lambermont 12315f4d0e Initial revision
2002-10-12 11:37:38 +00:00

1096 lines
22 KiB
C

/* ***************************************
*
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version. The Blender
* Foundation also sells licenses for use in proprietary software under
* the Blender License. See http://www.blender.org/BL/ for information
* about this.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): none yet.
*
* ***** END GPL/BL DUAL LICENSE BLOCK *****
node.c nov/dec 1992
may 1999
$Id$
*************************************** */
#include <stdio.h>
#include <math.h>
#include <string.h>
#include "MEM_guardedalloc.h"
#include "BLI_blenlib.h"
#include "BLI_arithb.h"
#include "BKE_global.h"
#include "BKE_main.h"
#include "BIF_toolbox.h"
#include "radio.h"
/* locals */
void *malloc_fast(int size);
void *calloc_fast(int size);
void free_fast(void *poin, int siz);
void deleteTriNodes(RNode *node);
/* lower because of local type define */
/* void check_mallocgroup(MallocGroup *mg); */
/* ********** fastmalloc ************** */
#define MAL_GROUPSIZE 256
#define MAL_AVAILABLE 1
#define MAL_FULL 2
ListBase MallocBase= {0, 0};
int totfastmem= 0;
typedef struct MallocGroup {
struct MallocGroup *next, *prev;
short size, flag;
short curfree, tot;
char flags[MAL_GROUPSIZE];
char *data;
} MallocGroup;
/* one more local */
void check_mallocgroup(MallocGroup *mg);
void check_mallocgroup(MallocGroup *mg)
{
int a;
char *cp;
if(mg->tot==MAL_GROUPSIZE) {
mg->flag= MAL_FULL;
return;
}
cp= mg->flags;
if(mg->curfree<MAL_GROUPSIZE-1) {
if(cp[mg->curfree+1]==0) {
mg->curfree++;
return;
}
}
if(mg->curfree>0) {
if(cp[mg->curfree-1]==0) {
mg->curfree--;
return;
}
}
for(a=0; a<MAL_GROUPSIZE; a++) {
if(cp[a]==0) {
mg->curfree= a;
return;
}
}
printf("fastmalloc: shouldnt be here\n");
}
void *malloc_fast(int size)
{
MallocGroup *mg;
void *retval;
mg= MallocBase.last;
while(mg) {
if(mg->size==size) {
if(mg->flag & MAL_AVAILABLE) {
mg->flags[mg->curfree]= 1;
mg->tot++;
retval= mg->data+mg->curfree*mg->size;
check_mallocgroup(mg);
return retval;
}
}
mg= mg->prev;
}
/* no free block found */
mg= MEM_callocN(sizeof(MallocGroup), "mallocgroup");
BLI_addtail(&MallocBase, mg);
mg->data= MEM_mallocN(MAL_GROUPSIZE*size, "mallocgroupdata");
mg->flag= MAL_AVAILABLE;
mg->flags[0]= 1;
mg->curfree= 1;
mg->size= size;
mg->tot= 1;
totfastmem+= sizeof(MallocGroup)+MAL_GROUPSIZE*size;
return mg->data;
}
void *calloc_fast(int size)
{
void *poin;
poin= malloc_fast(size);
memset(poin, 0, size);
return poin;
}
void free_fast(void *poin, int size)
{
MallocGroup *mg;
long val;
mg= MallocBase.last;
while(mg) {
if(mg->size==size) {
if( ((long)poin) >= ((long)mg->data) ) {
if( ((long)poin) < ((long)(mg->data+MAL_GROUPSIZE*size)) ) {
val= ((long)poin) - ((long)mg->data);
val/= size;
mg->curfree= val;
mg->flags[val]= 0;
mg->flag= MAL_AVAILABLE;
mg->tot--;
if(mg->tot==0) {
BLI_remlink(&MallocBase, mg);
MEM_freeN(mg->data);
MEM_freeN(mg);
totfastmem-= sizeof(MallocGroup)+MAL_GROUPSIZE*size;
}
return;
}
}
}
mg= mg->prev;
}
printf("fast free: pointer not in memlist %p size %d\n",
poin, size);
}
/* security: only one function in a time can use it */
static char *fastmallocstr= 0;
void free_fastAll()
{
MallocGroup *mg;
mg= MallocBase.first;
while(mg) {
BLI_remlink(&MallocBase, mg);
MEM_freeN(mg->data);
MEM_freeN(mg);
mg= MallocBase.first;
}
totfastmem= 0;
fastmallocstr= 0;
}
void start_fastmalloc(char *str)
{
if(fastmallocstr) {
error("Fastmalloc in use: %s", fastmallocstr);
return;
}
fastmallocstr= str;
}
/* **************************************** */
float nodelimit;
void setnodelimit(float limit)
{
nodelimit= limit;
}
/* ************ GEHEUGENBEHEER *********** */
int Ntotvert=0, Ntotnode=0, Ntotpatch=0;
float *mallocVert()
{
Ntotvert++;
return (float *)malloc_fast(16);
}
float *callocVert()
{
Ntotvert++;
return (float *)calloc_fast(16);
}
void freeVert(float *vert)
{
free_fast(vert, 16);
Ntotvert--;
}
RNode *mallocNode()
{
Ntotnode++;
return (RNode *)malloc_fast(sizeof(RNode));
}
RNode *callocNode()
{
Ntotnode++;
return (RNode *)calloc_fast(sizeof(RNode));
}
void freeNode(RNode *node)
{
free_fast(node, sizeof(RNode));
Ntotnode--;
}
void freeNode_recurs(RNode *node)
{
if(node->down1) {
freeNode_recurs(node->down1);
freeNode_recurs(node->down2);
}
node->down1= node->down2= 0;
freeNode(node);
}
RPatch *mallocPatch()
{
Ntotpatch++;
return (RPatch *)malloc_fast(sizeof(RPatch));
}
RPatch *callocPatch()
{
Ntotpatch++;
return (RPatch *)calloc_fast(sizeof(RPatch));
}
void freePatch(RPatch *patch)
{
free_fast(patch, sizeof(RPatch));
Ntotpatch--;
}
/* ************ SUBDIVIDE *********** */
void replaceAllNode(RNode *neighb, RNode *newn)
{
/* verandert van alle buren de edgepointers die naar newn->up wijzen in new */
int ok= 0;
if(neighb==0) return;
if(newn->up==0) return;
if(neighb->ed1==newn->up) {
neighb->ed1= newn;
ok= 1;
}
else if(neighb->ed2==newn->up) {
neighb->ed2= newn;
ok= 1;
}
else if(neighb->ed3==newn->up) {
neighb->ed3= newn;
ok= 1;
}
else if(neighb->ed4==newn->up) {
neighb->ed4= newn;
ok= 1;
}
if(ok && neighb->down1) {
replaceAllNode(neighb->down1, newn);
replaceAllNode(neighb->down2, newn);
}
}
void replaceAllNodeInv(RNode *neighb, RNode *old)
{
/* verandert van alle buren de edgepointers die naar old wijzen in old->up */
if(neighb==0) return;
if(old->up==0) return;
if(neighb->ed1==old) {
neighb->ed1= old->up;
}
else if(neighb->ed2==old) {
neighb->ed2= old->up;
}
else if(neighb->ed3==old) {
neighb->ed3= old->up;
}
else if(neighb->ed4==old) {
neighb->ed4= old->up;
}
if(neighb->down1) {
replaceAllNodeInv(neighb->down1, old);
replaceAllNodeInv(neighb->down2, old);
}
}
void replaceAllNodeUp(RNode *neighb, RNode *old)
{
/* verandert van alle buren de edgepointers die naar old wijzen in old->up */
if(neighb==0) return;
if(old->up==0) return;
neighb= neighb->up;
if(neighb==0) return;
if(neighb->ed1==old) {
neighb->ed1= old->up;
}
else if(neighb->ed2==old) {
neighb->ed2= old->up;
}
else if(neighb->ed3==old) {
neighb->ed3= old->up;
}
else if(neighb->ed4==old) {
neighb->ed4= old->up;
}
if(neighb->up) {
replaceAllNodeUp(neighb, old);
}
}
void replaceTestNode(RNode *neighb, RNode **edpp, RNode *newn, int level, float *vert)
{
/* IF neighb->ed wijst naar newn->up
* IF edgelevels gelijk
IF testvert zit in neighb->ed
pointers beide kanten op veranderen
ELSE
RETURN
ELSE
IF neighb edgelevel is dieper
verander neighb pointer
*/
int ok= 0;
if(neighb==0) return;
if(newn->up==0) return;
if(neighb->ed1==newn->up) {
if(neighb->lev1==level) {
if(vert==neighb->v1 || vert==neighb->v2) {
*edpp= neighb;
neighb->ed1= newn;
}
else return;
}
else if(neighb->lev1>level) {
neighb->ed1= newn;
}
ok= 1;
}
else if(neighb->ed2==newn->up) {
if(neighb->lev2==level) {
if(vert==neighb->v2 || vert==neighb->v3) {
*edpp= neighb;
neighb->ed2= newn;
}
else return;
}
else if(neighb->lev2>level) {
neighb->ed2= newn;
}
ok= 1;
}
else if(neighb->ed3==newn->up) {
if(neighb->lev3==level) {
if(neighb->type==3) {
if(vert==neighb->v3 || vert==neighb->v1) {
*edpp= neighb;
neighb->ed3= newn;
}
else return;
}
else {
if(vert==neighb->v3 || vert==neighb->v4) {
*edpp= neighb;
neighb->ed3= newn;
}
else return;
}
}
else if(neighb->lev3>level) {
neighb->ed3= newn;
}
ok= 1;
}
else if(neighb->ed4==newn->up) {
if(neighb->lev4==level) {
if(vert==neighb->v4 || vert==neighb->v1) {
*edpp= neighb;
neighb->ed4= newn;
}
else return;
}
else if(neighb->lev4>level) {
neighb->ed4= newn;
}
ok= 1;
}
if(ok && neighb->down1) {
replaceTestNode(neighb->down1, edpp, newn, level, vert);
replaceTestNode(neighb->down2, edpp, newn, level, vert);
}
}
int setvertexpointersNode(RNode *neighb, RNode *node, int level, float **v1, float **v2)
{
/* vergelijkt edgelevels , als gelijk zet het de vertexpointers */
if(neighb==0) return 0;
if(neighb->ed1==node) {
if(neighb->lev1==level) {
*v1= neighb->v1;
*v2= neighb->v2;
return 1;
}
}
else if(neighb->ed2==node) {
if(neighb->lev2==level) {
*v1= neighb->v2;
*v2= neighb->v3;
return 1;
}
}
else if(neighb->ed3==node) {
if(neighb->lev3==level) {
if(neighb->type==3) {
*v1= neighb->v3;
*v2= neighb->v1;
}
else {
*v1= neighb->v3;
*v2= neighb->v4;
}
return 1;
}
}
else if(neighb->ed4==node) {
if(neighb->lev4==level) {
*v1= neighb->v4;
*v2= neighb->v1;
return 1;
}
}
return 0;
}
float edlen(float *v1, float *v2)
{
return (v1[0]-v2[0])*(v1[0]-v2[0])+ (v1[1]-v2[1])*(v1[1]-v2[1])+ (v1[2]-v2[2])*(v1[2]-v2[2]);
}
void subdivideTriNode(RNode *node, RNode *edge)
{
RNode *n1, *n2, *up;
float fu, fv, fl, *v1, *v2; /* , AreaT3Dfl(); ... from arithb... */
int uvl;
if(node->down1 || node->down2) {
/* printf("trinode: subd already done\n"); */
return;
}
/* bepaal subdivide richting */
if(edge==0) {
/* areathreshold */
if(node->area<nodelimit) return;
fu= edlen(node->v1, node->v2);
fv= edlen(node->v2, node->v3);
fl= edlen(node->v3, node->v1);
if(fu>fv && fu>fl) uvl= 1;
else if(fv>fu && fv>fl) uvl= 2;
else uvl= 3;
}
else {
if(edge==node->ed1) uvl= 1;
else if(edge==node->ed2) uvl= 2;
else uvl= 3;
}
/* moeten naastliggende nodes dieper? Recursief! */
n1= 0;
if(uvl==1) {
if(node->ed1 && node->ed1->down1==0) n1= node->ed1;
}
else if(uvl==2) {
if(node->ed2 && node->ed2->down1==0) n1= node->ed2;
}
else {
if(node->ed3 && node->ed3->down1==0) n1= node->ed3;
}
if(n1) {
up= node->up;
while(up) { /* ook testen op ed4 !!! */
if(n1->ed1==up || n1->ed2==up || n1->ed3==up || n1->ed4==up) {
subdivideNode(n1, up);
break;
}
up= up->up;
}
}
/* Het subdividen */
n1= mallocNode();
memcpy(n1, node, sizeof(RNode));
n2= mallocNode();
memcpy(n2, node, sizeof(RNode));
n1->up= node;
n2->up= node;
node->down1= n1;
node->down2= n2;
/* subdivide edge 1 */
if(uvl==1) {
/* EERSTE NODE krijgt edge 2 */
n1->ed3= n2;
n1->lev3= 0;
replaceAllNode(n1->ed2, n1);
n1->lev1++;
replaceTestNode(n1->ed1, &(n1->ed1), n1, n1->lev1, n1->v2);
/* TWEEDE NODE krijgt edge 3 */
n2->ed2= n1;
n2->lev2= 0;
replaceAllNode(n2->ed3, n2);
n2->lev1++;
replaceTestNode(n2->ed1, &(n2->ed1), n2, n2->lev1, n2->v1);
/* NIEUWE VERTEX uit edge 1 */
if( setvertexpointersNode(n1->ed1, n1, n1->lev1, &v1, &v2) ) { /* nodes hebben gelijke levels */
if(v1== n1->v2) {
n1->v1= v2;
n2->v2= v2;
}
else {
n1->v1= v1;
n2->v2= v1;
}
}
else {
n1->v1= n2->v2= mallocVert();
n1->v1[0]= 0.5*(node->v1[0]+ node->v2[0]);
n1->v1[1]= 0.5*(node->v1[1]+ node->v2[1]);
n1->v1[2]= 0.5*(node->v1[2]+ node->v2[2]);
n1->v1[3]= node->v1[3]; /* color */
}
}
else if(uvl==2) {
/* EERSTE NODE krijgt edge 1 */
n1->ed3= n2;
n1->lev3= 0;
replaceAllNode(n1->ed1, n1);
n1->lev2++;
replaceTestNode(n1->ed2, &(n1->ed2), n1, n1->lev2, n1->v2);
/* TWEEDE NODE krijgt edge 3 */
n2->ed1= n1;
n2->lev1= 0;
replaceAllNode(n2->ed3, n2);
n2->lev2++;
replaceTestNode(n2->ed2, &(n2->ed2), n2, n2->lev2, n2->v3);
/* NIEUWE VERTEX uit edge 2 */
if( setvertexpointersNode(n1->ed2, n1, n1->lev2, &v1, &v2) ) { /* nodes hebben gelijke levels */
if(v1== n1->v2) {
n1->v3= v2;
n2->v2= v2;
}
else {
n1->v3= v1;
n2->v2= v1;
}
}
else {
n1->v3= n2->v2= mallocVert();
n1->v3[0]= 0.5*(node->v2[0]+ node->v3[0]);
n1->v3[1]= 0.5*(node->v2[1]+ node->v3[1]);
n1->v3[2]= 0.5*(node->v2[2]+ node->v3[2]);
n1->v3[3]= node->v1[3]; /* color */
}
}
else if(uvl==3) {
/* EERSTE NODE krijgt edge 1 */
n1->ed2= n2;
n1->lev2= 0;
replaceAllNode(n1->ed1, n1);
n1->lev3++;
replaceTestNode(n1->ed3, &(n1->ed3), n1, n1->lev3, n1->v1);
/* TWEEDE NODE krijgt edge 2 */
n2->ed1= n1;
n2->lev1= 0;
replaceAllNode(n2->ed2, n2);
n2->lev3++;
replaceTestNode(n2->ed3, &(n2->ed3), n2, n2->lev3, n2->v3);
/* NIEUWE VERTEX uit edge 3 */
if( setvertexpointersNode(n1->ed3, n1, n1->lev3, &v1, &v2) ) { /* nodes hebben gelijke levels */
if(v1== n1->v1) {
n1->v3= v2;
n2->v1= v2;
}
else {
n1->v3= v1;
n2->v1= v1;
}
}
else {
n1->v3= n2->v1= mallocVert();
n1->v3[0]= 0.5*(node->v1[0]+ node->v3[0]);
n1->v3[1]= 0.5*(node->v1[1]+ node->v3[1]);
n1->v3[2]= 0.5*(node->v1[2]+ node->v3[2]);
n1->v3[3]= node->v3[3]; /* color */
}
}
n1->area= AreaT3Dfl(n1->v1, n1->v2, n1->v3);
n2->area= AreaT3Dfl(n2->v1, n2->v2, n2->v3);
}
void subdivideNode(RNode *node, RNode *edge)
{
RNode *n1, *n2, *up;
float fu, fv, *v1, *v2;/*, AreaQ3Dfl(); ... from arithb... */
int uvl;
if(Ntotnode>RG.maxnode) return;
if(node->type==3) {
subdivideTriNode(node, edge);
return;
}
if(node->down1 || node->down2) {
/* printf("subdivide Node: already done \n"); */
return;
}
/* bepaal subdivide richting */
if(edge==0) {
/* areathreshold */
if(node->area<nodelimit) {
return;
}
fu= fabs(node->v1[0]- node->v2[0])+ fabs(node->v1[1]- node->v2[1]) +fabs(node->v1[2]- node->v2[2]);
fv= fabs(node->v1[0]- node->v4[0])+ fabs(node->v1[1]- node->v4[1]) +fabs(node->v1[2]- node->v4[2]);
if(fu>fv) uvl= 1;
else uvl= 2;
}
else {
if(edge==node->ed1 || edge==node->ed3) uvl= 1;
else uvl= 2;
}
/* moeten naastliggende nodes dieper? Recursief! */
n1= n2= 0;
if(uvl==1) {
if(node->ed1 && node->ed1->down1==0) n1= node->ed1;
if(node->ed3 && node->ed3->down1==0) n2= node->ed3;
}
else {
if(node->ed2 && node->ed2->down1==0) n1= node->ed2;
if(node->ed4 && node->ed4->down1==0) n2= node->ed4;
}
if(n1) {
up= node->up;
while(up) {
if(n1->ed1==up || n1->ed2==up || n1->ed3==up || n1->ed4==up) {
/* printf("recurs subd\n"); */
subdivideNode(n1, up);
break;
}
up= up->up;
}
}
if(n2) {
up= node->up;
while(up) {
if(n2->ed1==up || n2->ed2==up || n2->ed3==up || n2->ed4==up) {
/* printf("recurs subd\n"); */
subdivideNode(n2, up);
break;
}
up= up->up;
}
}
/* Het subdividen */
n1= mallocNode();
memcpy(n1, node, sizeof(RNode));
n2= mallocNode();
memcpy(n2, node, sizeof(RNode));
n1->up= node;
n2->up= node;
node->down1= n1;
node->down2= n2;
/* subdivide edge 1 en 3 */
if(uvl==1) {
/* EERSTE NODE krijgt edge 2 */
n1->ed4= n2;
n1->lev4= 0;
replaceAllNode(n1->ed2, n1);
n1->lev1++;
n1->lev3++;
replaceTestNode(n1->ed1, &(n1->ed1), n1, n1->lev1, n1->v2);
replaceTestNode(n1->ed3, &(n1->ed3), n1, n1->lev3, n1->v3);
/* TWEEDE NODE krijgt edge 4 */
n2->ed2= n1;
n2->lev2= 0;
replaceAllNode(n2->ed4, n2);
n2->lev1++;
n2->lev3++;
replaceTestNode(n2->ed1, &(n2->ed1), n2, n2->lev1, n2->v1);
replaceTestNode(n2->ed3, &(n2->ed3), n2, n2->lev3, n2->v4);
/* NIEUWE VERTEX uit edge 1 */
if( setvertexpointersNode(n1->ed1, n1, n1->lev1, &v1, &v2) ) { /* nodes hebben gelijke levels */
if(v1== n1->v2) {
n1->v1= v2;
n2->v2= v2;
}
else {
n1->v1= v1;
n2->v2= v1;
}
}
else {
n1->v1= n2->v2= mallocVert();
n1->v1[0]= 0.5*(node->v1[0]+ node->v2[0]);
n1->v1[1]= 0.5*(node->v1[1]+ node->v2[1]);
n1->v1[2]= 0.5*(node->v1[2]+ node->v2[2]);
n1->v1[3]= node->v1[3]; /* color */
}
/* NIEUWE VERTEX uit edge 3 */
if( setvertexpointersNode(n1->ed3, n1, n1->lev3, &v1, &v2) ) { /* nodes hebben gelijke levels */
if(v1== n1->v3) {
n1->v4= v2;
n2->v3= v2;
}
else {
n1->v4= v1;
n2->v3= v1;
}
}
else {
n1->v4= n2->v3= mallocVert();
n1->v4[0]= 0.5*(node->v3[0]+ node->v4[0]);
n1->v4[1]= 0.5*(node->v3[1]+ node->v4[1]);
n1->v4[2]= 0.5*(node->v3[2]+ node->v4[2]);
n1->v4[3]= node->v4[3]; /* color */
}
}
/* subdivide edge 2 en 4 */
else if(uvl==2) {
/* EERSTE NODE krijgt edge 1 */
n1->ed3= n2;
n1->lev3= 0;
replaceAllNode(n1->ed1, n1);
n1->lev2++;
n1->lev4++;
replaceTestNode(n1->ed2, &(n1->ed2), n1, n1->lev2, n1->v2);
replaceTestNode(n1->ed4, &(n1->ed4), n1, n1->lev4, n1->v1);
/* TWEEDE NODE krijgt edge 3 */
n2->ed1= n1;
n2->lev1= 0;
replaceAllNode(n2->ed3, n2);
n2->lev2++;
n2->lev4++;
replaceTestNode(n2->ed2, &(n2->ed2), n2, n2->lev2, n2->v3);
replaceTestNode(n2->ed4, &(n2->ed4), n2, n2->lev4, n2->v4);
/* NIEUWE VERTEX uit edge 2 */
if( setvertexpointersNode(n1->ed2, n1, n1->lev2, &v1, &v2) ) { /* nodes hebben gelijke levels */
if(v1== n1->v2) {
n1->v3= v2;
n2->v2= v2;
}
else {
n1->v3= v1;
n2->v2= v1;
}
}
else {
n1->v3= n2->v2= mallocVert();
n1->v3[0]= 0.5*(node->v2[0]+ node->v3[0]);
n1->v3[1]= 0.5*(node->v2[1]+ node->v3[1]);
n1->v3[2]= 0.5*(node->v2[2]+ node->v3[2]);
n1->v3[3]= node->v3[3]; /* color */
}
/* NIEUWE VERTEX uit edge 4 */
if( setvertexpointersNode(n1->ed4, n1, n1->lev4, &v1, &v2) ) { /* nodes hebben gelijke levels */
if(v1== n1->v1) {
n1->v4= v2;
n2->v1= v2;
}
else {
n1->v4= v1;
n2->v1= v1;
}
}
else {
n1->v4= n2->v1= mallocVert();
n1->v4[0]= 0.5*(node->v1[0]+ node->v4[0]);
n1->v4[1]= 0.5*(node->v1[1]+ node->v4[1]);
n1->v4[2]= 0.5*(node->v1[2]+ node->v4[2]);
n1->v4[3]= node->v4[3]; /* color */
}
}
n1->area= AreaQ3Dfl(n1->v1, n1->v2, n1->v3, n1->v4);
n2->area= AreaQ3Dfl(n2->v1, n2->v2, n2->v3, n2->v4);
}
int comparelevel(RNode *node, RNode *nb, int level)
{
/* recursief afdalen: bij diepste node testen */
/* return 1 is gelijk of hoger */
if(nb==0) return 1;
if(nb->down1) {
return 0;
/* HIER ZIT EEN FOUT, MAAR WELKE? (zonder dit werkt 't ook, maar langzamer)
n1= nb->down1;
if(n1->ed1==node) return comparelevel(node, n1, level);
if(n1->ed2==node) return comparelevel(node, n1, level);
if(n1->ed3==node) return comparelevel(node, n1, level);
if(n1->ed4==node) return comparelevel(node, n1, level);
n1= nb->down2;
if(n1->ed1==node) return comparelevel(node, n1, level);
if(n1->ed2==node) return comparelevel(node, n1, level);
if(n1->ed3==node) return comparelevel(node, n1, level);
if(n1->ed4==node) return comparelevel(node, n1, level);
printf(" dit kan niet ");
return 0;
*/
}
if(nb->down1==0) {
/* if(nb->ed1==node) return (nb->lev1<=level); */
/* if(nb->ed2==node) return (nb->lev2<=level); */
/* if(nb->ed3==node) return (nb->lev3<=level); */
/* if(nb->ed4==node) return (nb->lev4<=level); */
return 1; /* is hogere node */
}
return 1;
}
void deleteTriNodes(RNode *node) /* beide kinderen van node */
{
RNode *n1, *n2;
/* als naastliggende nodes dieper zijn: geen delete */
/* enkel twee nodes testen, van andere verandert level niet */
n1= node->down1;
n2= node->down2;
if(n1==0 || n2==0) return;
if(n1->down1 || n2->down1) return;
/* aan edges mag geen gesubdivide node zitten */
if(n1->ed1 && n1->ed1->down1) return;
if(n1->ed2 && n1->ed2->down1) return;
if(n1->ed3 && n1->ed3->down1) return;
if(n2->ed1 && n2->ed1->down1) return;
if(n2->ed2 && n2->ed2->down1) return;
if(n2->ed3 && n2->ed3->down1) return;
replaceAllNodeInv(n1->ed1, n1);
replaceAllNodeInv(n1->ed2, n1);
replaceAllNodeInv(n1->ed3, n1);
replaceAllNodeUp(n1->ed1, n1);
replaceAllNodeUp(n1->ed2, n1);
replaceAllNodeUp(n1->ed3, n1);
replaceAllNodeInv(n2->ed1, n2);
replaceAllNodeInv(n2->ed2, n2);
replaceAllNodeInv(n2->ed3, n2);
replaceAllNodeUp(n2->ed1, n2);
replaceAllNodeUp(n2->ed2, n2);
replaceAllNodeUp(n2->ed3, n2);
n1->down1= (RNode *)12; /* voor debug */
n2->down1= (RNode *)12;
freeNode(n1);
freeNode(n2);
node->down1= node->down2= 0;
}
/* beide kinderen van node */
void deleteNodes(RNode *node)
{
RNode *n1, *n2;
/* als naastliggende nodes dieper zijn: geen delete */
/* enkel twee nodes testen, van andere verandert level niet */
if(node->type==3) {
deleteTriNodes(node);
return;
}
n1= node->down1;
n2= node->down2;
if(n1==0 || n2==0) return;
if(n1->down1 || n2->down1) return;
if(n1->ed3==n2) {
/* aan edges mag geen gesubdivide node zitten */
if(n1->ed1 && n1->ed1->down1) return;
if(n1->ed2 && n1->ed2->down1) return;
if(n1->ed4 && n1->ed4->down1) return;
if(n2->ed2 && n2->ed2->down1) return;
if(n2->ed3 && n2->ed3->down1) return;
if(n2->ed4 && n2->ed4->down1) return;
replaceAllNodeInv(n1->ed1, n1);
replaceAllNodeInv(n1->ed2, n1);
replaceAllNodeInv(n1->ed4, n1);
replaceAllNodeUp(n1->ed1, n1);
replaceAllNodeUp(n1->ed2, n1);
replaceAllNodeUp(n1->ed4, n1);
replaceAllNodeInv(n2->ed2, n2);
replaceAllNodeInv(n2->ed3, n2);
replaceAllNodeInv(n2->ed4, n2);
replaceAllNodeUp(n2->ed2, n2);
replaceAllNodeUp(n2->ed3, n2);
replaceAllNodeUp(n2->ed4, n2);
n1->down1= (RNode *)12; /* voor debug */
n2->down1= (RNode *)12;
freeNode(n1);
freeNode(n2);
node->down1= node->down2= 0;
return;
}
else if(n1->ed4==n2) {
if(n1->ed1 && n1->ed1->down1) return;
if(n1->ed2 && n1->ed2->down1) return;
if(n1->ed3 && n1->ed3->down1) return;
if(n2->ed1 && n2->ed1->down1) return;
if(n2->ed3 && n2->ed3->down1) return;
if(n2->ed4 && n2->ed4->down1) return;
replaceAllNodeInv(n1->ed1, n1);
replaceAllNodeInv(n1->ed2, n1);
replaceAllNodeInv(n1->ed3, n1);
replaceAllNodeUp(n1->ed1, n1);
replaceAllNodeUp(n1->ed2, n1);
replaceAllNodeUp(n1->ed3, n1);
replaceAllNodeInv(n2->ed1, n2);
replaceAllNodeInv(n2->ed3, n2);
replaceAllNodeInv(n2->ed4, n2);
replaceAllNodeUp(n2->ed1, n2);
replaceAllNodeUp(n2->ed3, n2);
replaceAllNodeUp(n2->ed4, n2);
n1->down1= (RNode *)12; /* voor debug */
n2->down1= (RNode *)12;
freeNode(n1);
freeNode(n2);
node->down1= node->down2= 0;
return;
}
}