*/
public class element {
- coordinate coordinates[];
- int numCoordinate;
- coordinate_t circumCenter;
- double circumRadius;
- double minAngle;
- edge edges[3];
- int numEdge;
- coordinate_t midpoints[3]; /* midpoint of each edge */
- double radii[3]; /* half of edge length */
- edge encroachedEdgePtr; /* opposite obtuse angle */
- boolean isSkinny;
- list_t neighborListPtr;
- boolean isGarbage;
- boolean isReferenced;
-
-
- extern double global_angleConstraint;
+ coordinate coordinates[];
+ int numCoordinate;
+ coordinate circumCenter;
+ double circumRadius;
+ double minAngle;
+ edge edges[];
+ int numEdge;
+ coordinate midpoints[]; /* midpoint of each edge */
+ double radii[]; /* half of edge length */
+ edge encroachedEdgePtr; /* opposite obtuse angle */
+ boolean isSkinny;
+ List_t neighborListPtr;
+ boolean isGarbage;
+ boolean isReferenced;
* -- Sets isSkinny to TRUE if the angle constraint is not met
* =============================================================================
*/
- void checkAngles () {
- double angleConstraint = global_angleConstraint;
+ void checkAngles (double angleConstraint) {
+ //double angleConstraint = global_angleConstraint;
minAngle = 180.0;
- assert(numCoordinate == 2 || numCoordinate == 3);
+ yada.Assert(numCoordinate == 2 || numCoordinate == 3);
isReferenced = false;
isSkinny = false;
encroachedEdgePtr = null;
double angle = coordinate_angle(coordinates[i],
coordinates[(i + 1) % 3],
coordinates[(i + 2) % 3]);
- assert(angle > 0.0);
- assert(angle < 180.0);
+ yada.Assert(angle > 0.0);
+ yada.Assert(angle < 180.0);
if (angle > 90.0) {
encroachedEdgePtr = edges[(i + 1) % 3];
}
minAngle = angle;
}
}
- assert(minAngle < 180.0);
+ yada.Assert(minAngle < 180.0);
}
}
void calculateCircumCircle() {
coordinate circumCenterPtr = this.circumCenter;
- assert(numCoordinate == 2 || numCoordinate == 3);
+ yada.Assert(numCoordinate == 2 || numCoordinate == 3);
if (numCoordinate == 2) {
circumCenterPtr.x = (coordinates[0].x + coordinates[1].x) / 2.0;
double denominator = 2 * ((bxDelta * cyDelta) - (cxDelta * byDelta));
double rx = ax - (xNumerator / denominator);
double ry = ay + (yNumerator / denominator);
- assert(fabs(denominator) > DBL_MIN); /* make sure not colinear */
+ yada.Assert(fabs(denominator) > DBL_MIN); /* make sure not colinear */
circumCenterPtr.x = rx;
circumCenterPtr.y = ry;
}
edge edgePtr = edges[i];
int cmp = coordinate_compare(firstPtr, secondPtr);
- assert(cmp != 0);
+ yada.Assert(cmp != 0);
if (cmp < 0) {
edgePtr.firstPtr = firstPtr;
edgePtr.secondPtr = secondPtr;
*/
public element(coordinate[] coordinates, int numCoordinate) {
this.coordinates=new coordinate[3];
+ this.midpoints=new coordinate[3]; /* midpoint of each edge */
+ this.radii=new double[3]; /* half of edge length */
+
+ this.edges=new edge[3];
for (int i = 0; i < numCoordinate; i++) {
this.coordinates[i] = coordinates[i];
}
* For use in list_t
* ============================================================================
*/
- int element_listCompareEdge (const void* aPtr, const void* bPtr) {
- edge_t* aEdgePtr = (edge_t*)(aPtr);
- edge_t* bEdgePtr = (edge_t*)(bPtr);
+ int element_listCompareEdge (Object aPtr, Object bPtr) {
+ edge aEdgePtr = (edge)(aPtr);
+ edge bEdgePtr = (edge)(bPtr);
return compareEdge(aEdgePtr, bEdgePtr);
}
}
}
- if (bElementPtr->encroachedEdgePtr) {
+ if (bElementPtr.encroachedEdgePtr) {
return -1;
}
return midpoints[e];
}
}
- assert(0);
+ yada.Assert(0);
}
return circumCenter;
}
* Return FALSE if minimum angle constraint not met
* =============================================================================
*/
- boolean element_checkAngles() {
- double angleConstraint = global_angleConstraint;
+ boolean element_checkAngles(double angleConstraint) {
+ // double angleConstraint = global_angleConstraint;
if (numCoordinate == 3) {
for (int i = 0; i < 3; i++) {
double angle = coordinate_angle(coordinates[i],
element rootElementPtr;
Queue_t initBadQueuePtr;
int size;
- SET_T* boundarySetPtr;
+ SET_T boundarySetPtr;
/* =============================================================================
* mesh_alloc
rootElementPtr = null;
initBadQueuePtr = new Queue_t(-1);
size = 0;
- boundarySetPtr = SET_ALLOC(null, &element_listCompareEdge);
+ boundarySetPtr = SET_ALLOC(null, element_listCompareEdge);
}
* for checking the validity of the final mesh.
*/
if (rootElementPtr==null) {
- rootElementPtr=elementPtr);
+ rootElementPtr=elementPtr;
}
/*
int numEdge = elementPtr.element_getNumEdge();
for (int i = 0; i < numEdge; i++) {
edge edgePtr = elementPtr.element_getEdge(i);
- if (!MAP_CONTAINS(edgeMapPtr, (void*)edgePtr)) {
+ if (!MAP_CONTAINS(edgeMapPtr, edgePtr)) {
/* Record existance of this edge */
boolean isSuccess =
- PMAP_INSERT(edgeMapPtr, (void*)edgePtr, (void*)elementPtr);
- assert(isSuccess);
+ PMAP_INSERT(edgeMapPtr, edgePtr, elementPtr);
+ yada.Assert(isSuccess);
} else {
/*
* Shared edge; update each element's neighborList
*/
boolean isSuccess;
- element sharerPtr = (element_t*)MAP_FIND(edgeMapPtr, edgePtr);
- assert(sharerPtr); /* cannot be shared by >2 elements */
+ element sharerPtr = (element)MAP_FIND(edgeMapPtr, edgePtr);
+ yada.Assert(sharerPtr!=null); /* cannot be shared by >2 elements */
elementPtr.element_addNeighbor(sharerPtr);
sharerPtr.element_addNeighbor(elementPtr);
isSuccess = PMAP_REMOVE(edgeMapPtr, edgePtr);
- assert(isSuccess);
+ yada.Assert(isSuccess);
isSuccess = PMAP_INSERT(edgeMapPtr,
edgePtr,
- NULL); /* marker to check >2 sharers */
- assert(isSuccess);
+ null); /* marker to check >2 sharers */
+ yada.Assert(isSuccess);
}
}
* =============================================================================
*/
public void TMmesh_remove(element elementPtr) {
- assert(!elementPtr.element_isGarbage());
+ yada.Assert(!elementPtr.element_isGarbage());
/*
* If removing root, a new root is selected on the next mesh_insert, which
* Remove from neighbors
*/
list_iter_t it;
- List neighborListPtr = elementPtr.element_getNeighborListPtr();
- TMLIST_ITER_RESET(&it, neighborListPtr);
- while (TMLIST_ITER_HASNEXT(&it, neighborListPtr)) {
- element neighborPtr = (element)TMLIST_ITER_NEXT(&it, neighborListPtr);
+ List_t neighborListPtr = elementPtr.element_getNeighborListPtr();
+ TMLIST_ITER_RESET(it, neighborListPtr);
+ while (TMLIST_ITER_HASNEXT(it, neighborListPtr)) {
+ element neighborPtr = (element)TMLIST_ITER_NEXT(it, neighborListPtr);
List_t neighborNeighborListPtr = neighborPtr.element_getNeighborListPtr();
boolean status = neighborNeighborListPtr.remove(elementPtr);
- assert(status);
+ yada.Assert(status);
}
elementPtr.element_isGarbage(true);
* TMmesh_insertBoundary
* =============================================================================
*/
-boolean TMmesh_insertBoundary (meshPtr, edge boundaryPtr) {
+boolean TMmesh_insertBoundary(edge boundaryPtr) {
return TMSET_INSERT(boundarySetPtr, boundaryPtr);
}
* TMmesh_removeBoundary
* =============================================================================
*/
-boolean TMmesh_removeBoundary (meshPtr, edge boundaryPtr) {
+boolean TMmesh_removeBoundary(edge boundaryPtr) {
return TMSET_REMOVE(boundarySetPtr, boundaryPtr);
}
int numCoordinate,
MAP_T edgeMapPtr) {
element elementPtr = new element(coordinates, numCoordinate);
- assert(elementPtr);
+ yada.Assert(elementPtr);
if (numCoordinate == 2) {
edge boundaryPtr = elementPtr.element_getEdge(0);
boolean status = SET_INSERT(boundarySetPtr, boundaryPtr);
- assert(status);
+ yada.Assert(status);
}
mesh_insert(elementPtr, edgeMapPtr);
if (elementPtr.element_isBad()) {
boolean status = initBadQueuePtr.queue_push(elementPtr);
- assert(status);
+ yada.Assert(status);
}
}
* =============================================================================
*/
int mesh_read(String fileNamePrefix) {
- FILE* inputFile;
- coordinate_t* coordinates;
- char fileName[256];
+ FILE inputFile;
+ coordinate coordinates;
+ char fileName[]=new char[256];
int fileNameSize = sizeof(fileName) / sizeof(fileName[0]);
- char inputBuff[256];
+ char inputBuff[]=new char[256];
int inputBuffSize = sizeof(inputBuff) / sizeof(inputBuff[0]);
int numEntry;
int numDimension;
int i;
int numElement = 0;
- MAP_T* edgeMapPtr = MAP_ALLOC(NULL, &element_mapCompareEdge);
- assert(edgeMapPtr);
+ MAP_T edgeMapPtr = MAP_ALLOC(NULL, element_mapCompareEdge);
+ yada.Assert(edgeMapPtr);
/*
* Read .node file
*/
snprintf(fileName, fileNameSize, "%s.node", fileNamePrefix);
inputFile = fopen(fileName, "r");
- assert(inputFile);
+ yada.Assert(inputFile);
fgets(inputBuff, inputBuffSize, inputFile);
- sscanf(inputBuff, "%li %li", &numEntry, &numDimension);
- assert(numDimension == 2); /* must be 2-D */
+ sscanf(inputBuff, "%li %li", numEntry, numDimension);
+ yada.Assert(numDimension == 2); /* must be 2-D */
numCoordinate = numEntry + 1; /* numbering can start from 1 */
- coordinates = (coordinate_t*)malloc(numCoordinate * sizeof(coordinate_t));
- assert(coordinates);
+ coordinates = new coordinate[numCoordinate];
for (i = 0; i < numEntry; i++) {
int id;
double x;
if (inputBuff[0] == '#') {
continue; /* TODO: handle comments correctly */
}
- sscanf(inputBuff, "%li %lf %lf", &id, &x, &y);
+ sscanf(inputBuff, "%li %lf %lf", id, x, y);
coordinates[id].x = x;
coordinates[id].y = y;
}
- assert(i == numEntry);
+ yada.Assert(i == numEntry);
fclose(inputFile);
/*
*/
snprintf(fileName, fileNameSize, "%s.poly", fileNamePrefix);
inputFile = fopen(fileName, "r");
- assert(inputFile);
+ yada.Assert(inputFile);
fgets(inputBuff, inputBuffSize, inputFile);
- sscanf(inputBuff, "%li %li", &numEntry, &numDimension);
- assert(numEntry == 0); /* .node file used for vertices */
- assert(numDimension == 2); /* must be edge */
+ sscanf(inputBuff, "%li %li", numEntry, numDimension);
+ yada.Assert(numEntry == 0); /* .node file used for vertices */
+ yada.Assert(numDimension == 2); /* must be edge */
fgets(inputBuff, inputBuffSize, inputFile);
- sscanf(inputBuff, "%li", &numEntry);
+ sscanf(inputBuff, "%li", numEntry);
for (i = 0; i < numEntry; i++) {
int id;
int a;
int b;
- coordinate_t insertCoordinates[2];
+ coordinate insertCoordinates=new coordinate[2];
if (!fgets(inputBuff, inputBuffSize, inputFile)) {
break;
}
if (inputBuff[0] == '#') {
continue; /* TODO: handle comments correctly */
}
- sscanf(inputBuff, "%li %li %li", &id, &a, &b);
- assert(a >= 0 && a < numCoordinate);
- assert(b >= 0 && b < numCoordinate);
+ sscanf(inputBuff, "%li %li %li", id, a, b);
+ yada.Assert(a >= 0 && a < numCoordinate);
+ yada.Assert(b >= 0 && b < numCoordinate);
insertCoordinates[0] = coordinates[a];
insertCoordinates[1] = coordinates[b];
createElement(meshPtr, insertCoordinates, 2, edgeMapPtr);
}
- assert(i == numEntry);
+ yada.Assert(i == numEntry);
numElement += numEntry;
fclose(inputFile);
*/
snprintf(fileName, fileNameSize, "%s.ele", fileNamePrefix);
inputFile = fopen(fileName, "r");
- assert(inputFile);
+ yada.Assert(inputFile);
fgets(inputBuff, inputBuffSize, inputFile);
- sscanf(inputBuff, "%li %li", &numEntry, &numDimension);
- assert(numDimension == 3); /* must be triangle */
+ sscanf(inputBuff, "%li %li", numEntry, numDimension);
+ yada.Assert(numDimension == 3); /* must be triangle */
for (i = 0; i < numEntry; i++) {
int id;
int a;
int b;
int c;
- coordinate_t insertCoordinates[3];
+ coordinate insertCoordinates[]=new coordinate[3];
if (!fgets(inputBuff, inputBuffSize, inputFile)) {
break;
}
if (inputBuff[0] == '#') {
continue; /* TODO: handle comments correctly */
}
- sscanf(inputBuff, "%li %li %li %li", &id, &a, &b, &c);
- assert(a >= 0 && a < numCoordinate);
- assert(b >= 0 && b < numCoordinate);
- assert(c >= 0 && c < numCoordinate);
+ sscanf(inputBuff, "%li %li %li %li", id, a, b, c);
+ yada.Assert(a >= 0 && a < numCoordinate);
+ yada.Assert(b >= 0 && b < numCoordinate);
+ yada.Assert(c >= 0 && c < numCoordinate);
insertCoordinates[0] = coordinates[a];
insertCoordinates[1] = coordinates[b];
insertCoordinates[2] = coordinates[c];
createElement(meshPtr, insertCoordinates, 3, edgeMapPtr);
}
- assert(i == numEntry);
+ yada.Assert(i == numEntry);
numElement += numEntry;
fclose(inputFile);
System.out.println("Checking final mesh:");
Queue_t searchQueuePtr = new Queue_t(-1);
- assert(searchQueuePtr);
- MAP_T visitedMapPtr = MAP_ALLOC(NULL, &element_mapCompare);
- assert(visitedMapPtr);
+ yada.Assert(searchQueuePtr);
+ MAP_T visitedMapPtr = MAP_ALLOC(NULL, element_mapCompare);
+ yada.Assert(visitedMapPtr);
/*
* Do breadth-first search starting from rootElementPtr
*/
- assert(rootElementPtr!=null);
+ yada.Assert(rootElementPtr!=null);
searchQueuePtr.queue_push(rootElementPtr);
while (!searchQueuePtr.queue_isEmpty()) {
list_iter_t it;
List_t neighborListPtr;
element currentElementPtr = (element)queue_pop(searchQueuePtr);
- if (MAP_CONTAINS(visitedMapPtr, (void*)currentElementPtr)) {
+ if (MAP_CONTAINS(visitedMapPtr, currentElementPtr)) {
continue;
}
- boolean isSuccess = MAP_INSERT(visitedMapPtr, (void*)currentElementPtr, NULL);
- assert(isSuccess);
+ boolean isSuccess = MAP_INSERT(visitedMapPtr, currentElementPtr, null);
+ yada.Assert(isSuccess);
if (!currentElementPtr.checkAngles()) {
numBadTriangle++;
}
neighborListPtr = currentElementPtr.element_getNeighborListPtr();
- list_iter_reset(&it, neighborListPtr);
- while (list_iter_hasNext(&it, neighborListPtr)) {
+ list_iter_reset(it, neighborListPtr);
+ while (list_iter_hasNext(it, neighborListPtr)) {
element neighborElementPtr =
- (element)list_iter_next(&it, neighborListPtr);
+ (element)list_iter_next(it, neighborListPtr);
/*
* Continue breadth-first search
*/
- if (!MAP_CONTAINS(visitedMapPtr, (void*)neighborElementPtr)) {
+ if (!MAP_CONTAINS(visitedMapPtr, neighborElementPtr)) {
boolean isSuccess = searchQueuePtr.queue_push(neighborElementPtr);
- assert(isSuccess);
+ yada.Assert(isSuccess);
}
} /* for each neighbor */
numFalseNeighbor > 0 ||
numElement != expectedNumElement));
}
+}
\ No newline at end of file
*/
public region() {
expandQueuePtr = new Queue_t(-1);
- beforeListPtr = PLIST_ALLOC(&element_listCompare);
- borderListPtr = PLIST_ALLOC(&element_listCompareEdge);
+ beforeListPtr = PLIST_ALLOC(element_listCompare);
+ borderListPtr = PLIST_ALLOC(element_listCompareEdge);
badVectorPtr = new Vector_t(1);
}
*/
public void TMaddToBadVector(Vector_t badVectorPtr, element badElementPtr) {
boolean status = badVectorPtr.vector_pushBack(badElementPtr);
- assert(status);
+ yada.Assert(status);
badElementPtr.element_setIsReferenced(true);
}
public int TMretriangulate (element elementPtr,
region regionPtr,
mesh meshPtr,
- MAP_T* edgeMapPtr) {
+ MAP_T edgeMapPtr) {
Vector_t badVectorPtr = regionPtr.badVectorPtr; /* private */
list_t beforeListPtr = regionPtr.beforeListPtr; /* private */
list_t borderListPtr = regionPtr.borderListPtr; /* private */
list_iter_t it;
int numDelta = 0;
- assert(edgeMapPtr);
+ yada.Assert(edgeMapPtr);
coordinate centerCoordinate = elementPtr.element_getNewPoint();
* Remove the old triangles
*/
- list_iter_reset(&it, beforeListPtr);
- while (list_iter_hasNext(&it, beforeListPtr)) {
- element beforeElementPtr = (element)list_iter_next(&it, beforeListPtr);
+ list_iter_reset(it, beforeListPtr);
+ while (list_iter_hasNext(it, beforeListPtr)) {
+ element beforeElementPtr = (element)list_iter_next(it, beforeListPtr);
meshPtr.TMmesh_remove(beforeElementPtr);
}
coordinates[1] = (coordinate)(edgePtr.firstPtr);
element aElementPtr = new element(coordinates, 2);
- assert(aElementPtr);
+ yada.Assert(aElementPtr);
meshPtr.TMmesh_insert(aElementPtr, edgeMapPtr);
- coordinates[1] = (coordinate)(edgePtr->secondPtr);
+ coordinates[1] = (coordinate)edgePtr.secondPtr;
element bElementPtr = new element(coordinates, 2);
- assert(bElementPtr);
+ yada.Assert(bElementPtr);
meshPtr.TMmesh_insert(bElementPtr, edgeMapPtr);
boolean status = meshPtr.TMmesh_removeBoundary(elementPtr.element_getEdge(0));
- assert(status);
+ yada.Assert(status);
status = mesPtr.TMmesh_insertBoundary(aElementPtr.element_getEdge(0));
- assert(status);
+ yada.Assert(status);
status = meshPtr.TMmesh_insertBoundary(bElementPtr.element_getEdge(0));
- assert(status);
+ yada.Assert(status);
numDelta += 2;
}
* point and the two points from the border segment.
*/
- list_iter_reset(&it, borderListPtr);
- while (list_iter_hasNext(&it, borderListPtr)) {
+ list_iter_reset(it, borderListPtr);
+ while (list_iter_hasNext(it, borderListPtr)) {
coordinate coordinates[]=new coordinates[3];
- edge borderEdgePtr = (edge)list_iter_next(&it, borderListPtr);
- assert(borderEdgePtr);
+ edge borderEdgePtr = (edge)list_iter_next(it, borderListPtr);
+ yada.Assert(borderEdgePtr);
coordinates[0] = centerCoordinate;
coordinates[1] = (coordinate)(borderEdgePtr.firstPtr);
coordinates[2] = (coordinate)(borderEdgePtr.secondPtr);
element afterElementPtr = new element(coordinates, 3);
- assert(afterElementPtr);
+ yada.Assert(afterElementPtr!=null);
meshPtr.TMmesh_insert(afterElementPtr, edgeMapPtr);
if (afterElementPTr.element_isBad()) {
TMaddToBadVector(badVectorPtr, afterElementPtr);
element TMgrowRegion(element centerElementPtr,
region regionPtr,
mesh meshPtr,
- MAP_T* edgeMapPtr) {
+ MAP_T edgeMapPtr) {
boolean isBoundary = false;
if (centerElementPtr.element_getNumEdge() == 1) {
List_t neighborListPtr = currentElementPtr.element_getNeighborListPtr();
list_iter_t it;
- TMLIST_ITER_RESET(&it, neighborListPtr);
- while (TMLIST_ITER_HASNEXT(&it, neighborListPtr)) {
- element neighborElementPtr = (element)TMLIST_ITER_NEXT(&it, neighborListPtr);
+ TMLIST_ITER_RESET(it, neighborListPtr);
+ while (TMLIST_ITER_HASNEXT(it, neighborListPtr)) {
+ element neighborElementPtr = (element)TMLIST_ITER_NEXT(it, neighborListPtr);
neighborElementPtr.element_isGarbage(); /* so we can detect conflicts */
if (!beforeListPtr.find(neighborElementPtr)) {
if (neighborElementPtr.element_isInCircumCircle(centerCoordinatePtr)) {
} else {
/* Continue breadth-first search */
boolean isSuccess = expandQueuePtr.queue_push(neighborElementPtr);
- assert(isSuccess);
+ yada.Assert(isSuccess);
}
} else {
/* This element borders region; save info for retriangulation */
elementPtr.element_isGarbage(); /* so we can detect conflicts */
while (true) {
- edgeMapPtr = PMAP_ALLOC(NULL, &element_mapCompareEdge);
- assert(edgeMapPtr);
+ edgeMapPtr = PMAP_ALLOC(NULL, element_mapCompareEdge);
+ yada.Assert(edgeMapPtr);
encroachElementPtr = TMgrowRegion(elementPtr,
this,
meshPtr,
if (badElementPtr.element_isGarbage()) {
} else {
boolean status = workHeapPtr.heap_insert(badElementPtr);
- assert(status);
+ yada.Assert(status);
}
}
}
projects / IRC.git / commitdiff