/*Testing heap data stracure*/
int main(){
int * head = heapCreate(15);
int i;
for(i=1;i<10;i++)
heapInsert(i,head);
heapPrint(head);
printf("\nremove element : %d\n",heapRemove(head));
printf("\n\n");
heapPrint(head);
printf("\nremove element : %d\n",heapRemove(head));
printf("\n\n");
heapInsert(120,head);
heapInsert(6,head);
heapInsert(5,head);
heapPrint(head);
int arr[] = {46, 109, 711, 275, 196, 367,545,256,789,267,552};
int * head1= heapify(arr,11);
printf("\n\n");
heapPrint(head1);
return 0;
}
void heapSort(int* arr, int size){
int count = 0, size1;
int* temp = (int*)malloc(size*sizeof(int));
for(count; count < size; count++){
insert(arr[count], temp, count-1);
}
count = 0;
size1 = size;
for(count; count < size; count++){
arr[count] = heapRemove(temp, size1--);
}
free(temp);
}
static int
checkASched(Heap* heap, int (*ok)(Block*))
{
int cnt = 0;
Block* b = heapPeek(heap);
if (b == NULL) return 0;
while ((b != NULL) && ok(b)) {
heapRemove(heap);
b->localTime = globalTimeStamp;
cnt++;
msg2vm(b, CMD_RUN, b->localTime);
b->lastSimTime = b->localTime;
b = heapPeek(heap);
}
return cnt;
}
int peFindPathWW(PED* PE, MapNode* Start, MapNode* End, peTime StartTime, int Speed, PathStep** path)
{
MapNode* v = Start;
MapNode* s;
MapNode* best = Start;
int i;
int BaseCost;
int c,z;
if (Start == End) return 0;
PE->LastSID++;
heapClear(PE->Open);
v->g = 0;
v->f = 0;
v->h = (*PE->Heuristics)(PE, v, End);
v->Steps = 0;
v->Time = 0;
heapAdd(PE->Open, v);
while ((v != End) && (PE->Open->ActSize!=0))
{
#ifdef PE_MONITOR // pro monitorovani enginu
peENodes++;
#endif
v = PE->Open->HeapBuffer[1];
heapRemove(PE->Open, v);
// best position is the closest to the dest
// and the most distanced from the start
if ((v->h<best->h) || (v->h=best->h) && (v->g>best->g)) best = v;
for (i=0; i<8; i++)
{
s = peMapXY(PE, v->Pos.X+Dir2Delta[i][0], v->Pos.Y+Dir2Delta[i][1]); // s = sousedni policko
if ((!s) || (s->TC==PE->MAXTC) || (s->Owner!=-1)) continue;
if (s->SearchID == PE->LastSID)
{
if (s->HeapPos>0)
{
if (DirType[i]==0)
BaseCost = PE->HorizontalCost;
else
BaseCost = PE->DiagonalCost;
c = v->g + BaseCost;
z = v->FootSteps;
if (c + z < s->g)
{
s->h = (*PE->Heuristics)(PE, s, End);
s->Steps = v->Steps + 1;
s->Time = v->Time + Speed;
s->f = (*PE->MixFunction)(PE, c, s->h, z);
s->g = c + z;
s->CameFrom = v->Pos;
heapSiftUp(PE->Open, s->HeapPos);
}
}
// else konecny
}
else
{
s->SearchID = PE->LastSID;
if (DirType[i]==0)
BaseCost = PE->HorizontalCost;
else
BaseCost = PE->DiagonalCost;
c = v->g + BaseCost;
z = v->FootSteps;
s->h = (*PE->Heuristics)(PE, s, End);
s->Steps = v->Steps + 1;
s->Time = v->Time + Speed;
s->f = (*PE->MixFunction)(PE, c, s->h, z);
s->g = c + z;
s->CameFrom = v->Pos;
if (heapAdd(PE->Open, s)==HP_NOSPACE)
{
// we ran out off free heap space
// get the best known position and continue
// after walker reaches this position
End = best;
v = best;
break;
}
}
}
}
if (Start == End) return 0;
if (v!=End) return 0;
if (!peAddPath(PE, path, End->Steps+1)) return 0;
i=v->Steps+1;
while (i>0)
{
i--;
(*path)[i].Time = StartTime + v->Time;
(*path)[i].Type = PST_CONTINUE | PST_FOOTSTEP;
(*path)[i].Pos = v->Pos;
v->FootSteps+=PE->FootStepCost;
v=peMapXY(PE, v->CameFrom.X, v->CameFrom.Y);
}
(*path)[End->Steps].Type = PST_END | PST_FOOTSTEP;
return End->Steps+1;
}
void ApexQuadricSimplifier::collapseEdge(QuadricEdge& edge)
{
uint32_t vNr0 = edge.vertexNr[0];
uint32_t vNr1 = edge.vertexNr[1];
QuadricVertex* qv0 = mVertices[vNr0];
QuadricVertex* qv1 = mVertices[vNr1];
PX_ASSERT(qv0->bDeleted == 0);
PX_ASSERT(qv1->bDeleted == 0);
//FILE* f = NULL;
//fopen_s(&f, "c:\\collapse.txt", "a");
//fprintf_s(f, "Collapse Vertex %d -> %d\n", vNr1, vNr0);
// contract edge to the vertex0
qv0->pos = qv0->pos * (1.0f - edge.ratio) + qv1->pos * edge.ratio;
qv0->q += qv1->q;
// merge the edges
for (uint32_t i = 0; i < qv1->mEdges.size(); i++)
{
QuadricEdge& ei = mEdges[qv1->mEdges[i]];
uint32_t vi = ei.otherVertex(vNr1);
if (vi == vNr0)
{
continue;
}
// test whether we already have this neighbor
bool found = false;
for (uint32_t j = 0; j < qv0->mEdges.size(); j++)
{
QuadricEdge& ej = mEdges[qv0->mEdges[j]];
if (ej.otherVertex(vNr0) == vi)
{
found = true;
break;
}
}
if (found)
{
mVertices[vi]->removeEdge((int32_t)qv1->mEdges[i]);
ei.deleted = true;
if (ei.heapPos >= 0)
{
heapRemove((uint32_t)ei.heapPos, false);
}
#if TESTING
testHeap();
#endif
}
else
{
ei.replaceVertex(vNr1, vNr0);
qv0->mEdges.pushBack(qv1->mEdges[i]);
}
}
// remove common edge and update adjacent edges
for (int32_t i = (int32_t)qv0->mEdges.size() - 1; i >= 0; i--)
{
QuadricEdge& ei = mEdges[qv0->mEdges[(uint32_t)i]];
if (ei.otherVertex(vNr0) == vNr1)
{
qv0->mEdges.replaceWithLast((uint32_t)i);
}
else
{
computeCost(ei);
if (ei.heapPos >= 0)
{
heapUpdate((uint32_t)ei.heapPos);
}
#if TESTING
testHeap();
#endif
}
}
// delete collapsed triangles
for (int32_t i = (int32_t)qv0->mTriangles.size() - 1; i >= 0; i--)
{
uint32_t triangleIndex = qv0->mTriangles[(uint32_t)i];
QuadricTriangle& t = mTriangles[triangleIndex];
if (!t.deleted && t.containsVertex(vNr1))
{
mNumDeletedTriangles++;
t.deleted = true;
//fprintf_s(f, "Delete Triangle %d\n", triangleIndex);
PX_ASSERT(t.containsVertex(vNr0));
for (uint32_t j = 0; j < 3; j++)
{
mVertices[t.vertexNr[j]]->removeTriangle((int32_t)triangleIndex);
//fprintf_s(f, " v %d\n", t.vertexNr[j]);
}
}
}
// update triangles
for (uint32_t i = 0; i < qv1->mTriangles.size(); i++)
{
QuadricTriangle& t = mTriangles[qv1->mTriangles[i]];
if (t.deleted)
{
continue;
}
if (t.containsVertex(vNr1))
{
qv0->mTriangles.pushBack(qv1->mTriangles[i]);
}
t.replaceVertex(vNr1, vNr0);
}
mNumDeletedVertices += qv1->bDeleted == 1 ? 0 : 1;
qv1->bDeleted = 1;
edge.deleted = true;
//fclose(f);
#if TESTING
testMesh();
testHeap();
#endif
}
uint32_t ApexQuadricSimplifier::simplify(uint32_t subdivision, int32_t maxSteps, float maxError, IProgressListener* progressListener)
{
float maxLength = 0.0f;
uint32_t nbCollapsed = 0;
if (subdivision > 0)
{
maxLength = (mBounds.minimum - mBounds.maximum).magnitude() / subdivision;
}
uint32_t progressCounter = 0;
uint32_t maximum = maxSteps >= 0 ? maxSteps : mHeap.size();
HierarchicalProgressListener progress(100, progressListener);
progress.setSubtaskWork(90, "Isomesh simplicifaction");
#if TESTING
testHeap();
#endif
while (maxSteps == -1 || (maxSteps-- > 0))
{
if ((++progressCounter & 0xff) == 0)
{
const int32_t percent = (int32_t)(100 * progressCounter / maximum);
progress.setProgress(percent);
}
bool edgeFound = false;
QuadricEdge* e = NULL;
while (mHeap.size() - mNumDeletedHeapElements > 1)
{
e = mHeap[1];
if (maxError >= 0 && e->cost > maxError)
{
// get me out of here
edgeFound = false;
break;
}
if (legalCollapse(*e, maxLength))
{
heapRemove(1, false);
#if TESTING
testHeap();
#endif
edgeFound = true;
break;
}
uint32_t vNr0 = e->vertexNr[0];
uint32_t vNr1 = e->vertexNr[1];
QuadricVertex* qv0 = mVertices[vNr0];
QuadricVertex* qv1 = mVertices[vNr1];
heapRemove(1, qv0->bDeleted == 0 && qv1->bDeleted == 0);
#if TESTING
testHeap();
#endif
}
if (!edgeFound)
{
break;
}
collapseEdge(*e);
nbCollapsed++;
}
progress.completeSubtask();
progress.setSubtaskWork(10, "Heap rebuilding");
progressCounter = mNumDeletedHeapElements;
while (mNumDeletedHeapElements > 0)
{
if ((mNumDeletedHeapElements & 0x7f) == 0)
{
const int32_t percent = (int32_t)(100 * (progressCounter - mNumDeletedHeapElements) / progressCounter);
progress.setProgress(percent);
}
#if TESTING
testHeap();
#endif
mNumDeletedHeapElements--;
heapUpdate(mHeap.size() - 1 - mNumDeletedHeapElements);
}
progress.completeSubtask();
#if TESTING
testHeap();
#endif
return nbCollapsed;
}
