void split(Side_List **sideListH, long nodeNum)
{
// **sideListH; Listing of the sides in the domain for splitting DAG tree
// nodeNum; The index for the segment from sideList to use for pivot/split in DAG tree
long numSidesL =0; // the number of sides that are split off to the left
long numSidesR =0; // the number of sides that are split off to the right
Side_List **sidesLeftH = nil; // pointer to area of heap where sides are left
Side_List **sidesRightH = nil; // pointer to area of hear where sides are left
long numSideInList = _GetHandleSize((Handle)sideListH)/(sizeof(Side_List)); // The number of sides for splitting
long location,i;
long nodeP1,nodeP2;
Side_List sideListForNode;
long bCounterL =0, bCounterR =0; // counting the number of boundary seg in a side list
long branchNum;
static long nsx = 0;
nsx++;
if(nsx == 964)
{
nsx = 0;
}
if(gErrStr[0] ) goto done;
if(sideListH == nil)
{
strcpy(gErrStr,"Nil handle passed to split");
goto done;
}
branchNum = gDagTree.numBranches;
IncrementGDagTree();
(*gDagTree.treeHdl)[branchNum].topoIndex = oldNodeNum(((*sideListH)[nodeNum]).p1,((*sideListH)[nodeNum]).p2);
sidesLeftH = (Side_List **)_NewHandleClear((numSideInList)*sizeof(Side_List));
if(!sidesLeftH) {
strcpy(gErrStr,"Out of memory in split");
goto done;
}
sidesRightH = (Side_List **)_NewHandleClear((numSideInList)*sizeof(Side_List));
if(!sidesRightH) {
strcpy(gErrStr,"Out of memory in split");
goto done;
}
// find the node's points for determining relative right and left
nodeP1 = (*sideListH)[nodeNum].p1;
nodeP2 = (*sideListH)[nodeNum].p2;
// Do the actual splitting
for (i=0; i<numSideInList; i++) {
if(i == nodeNum) continue; // skip the case that nodeNum = i
// find the points associated with the test side
location = Right_or_Left(nodeP1,nodeP2,(*sideListH)[i].p1,(*sideListH)[i].p2);
// Distribute the sides to the two R/L areas of the heap
switch(location)
{
case -1:// left
(*sidesLeftH)[numSidesL++] = (*sideListH)[i];// copy the structure
break;
case 1: // right
(*sidesRightH)[numSidesR++] = (*sideListH)[i];// copy the structure
break;
case 0: // both
(*sidesLeftH)[numSidesL++] = (*sideListH)[i];// copy the structure
(*sidesRightH)[numSidesR++] = (*sideListH)[i];// copy the structure
break;
}
}
// trim sidesL and sidesR to numSidesL and numSidesR, respectively
_SetHandleSize((Handle)sidesLeftH,(numSidesL)*sizeof(Side_List));
_SetHandleSize((Handle)sidesRightH,(numSidesR)*sizeof(Side_List));
sideListForNode = (*sideListH)[nodeNum];
// Left Hand Side
if (numSidesL ==0) {
(*gDagTree.treeHdl)[branchNum].branchLeft = -8;
// Fake a split
if (sideListForNode.triLeft == -1)
{
strcpy(gErrStr,"Boundary not set up correctly - outside is on LHS");
goto done;
}
}
else {
// fTreeH in GNOME (a DAGHdl), member of fDagTree (part of GridVel, owned by the mover)
(*gDagTree.treeHdl)[branchNum].branchLeft = gDagTree.numBranches;
if(gErrStr[0]) goto done;
// set call for correct area for sides
nodeNum = newNodexx(sidesLeftH);
MySpinCursor(); // JLM 8/4/99
split(sidesLeftH,nodeNum); // recursively for LHS
//sidesLeftH = nil; // split disposed of this hdl
}
// Right Hand Side
if (numSidesR == 0)
{
// Fake a split
(*gDagTree.treeHdl)[branchNum].branchRight = -8; // place holder for steps in dag to all tri
}
else
{
(*gDagTree.treeHdl)[branchNum].branchRight = gDagTree.numBranches;
if(gErrStr[0]) goto done;
// set call for correct area for sides
nodeNum = newNodexx(sidesRightH);
split(sidesRightH,nodeNum); // recursively for RHS
//sidesRightH = nil; // split disposed of this hdl
}
done:
if(sidesRightH) DisposeHandle((Handle) sidesRightH);
sidesRightH = nil;
if(sidesLeftH) DisposeHandle((Handle) sidesLeftH);
sidesLeftH = nil;
return;
}
//OSErr NetCDFWindMoverCurv::ReadTopology(char* path, TMap **newMap)
OSErr NetCDFWindMoverCurv::ReadTopology(vector<string> &linesInFile, TMap **newMap)
{
// import NetCDF curvilinear info so don't have to regenerate
char s[1024], errmsg[256]/*, s[256], topPath[256]*/;
long i, numPoints, numTopoPoints, line = 0, numPts;
string currentLine;
//CHARH f = 0;
OSErr err = 0;
TopologyHdl topo=0;
LongPointHdl pts=0;
FLOATH depths=0;
VelocityFH velH = 0;
DAGTreeStruct tree;
WorldRect bounds = voidWorldRect;
TTriGridVel *triGrid = nil;
tree.treeHdl = 0;
TDagTree *dagTree = 0;
long numWaterBoundaries, numBoundaryPts, numBoundarySegs;
LONGH boundarySegs=0, waterBoundaries=0, boundaryPts=0;
errmsg[0]=0;
/*if (!path || !path[0]) return 0;
if (err = ReadFileContents(TERMINATED,0, 0, path, 0, 0, &f)) {
TechError("NetCDFWindMover::ReadTopology()", "ReadFileContents()", err);
goto done;
}
_HLock((Handle)f); // JLM 8/4/99
*/
// No header
// start with transformation array and vertices
MySpinCursor(); // JLM 8/4/99
//NthLineInTextOptimized(*f, (line)++, s, 1024);
currentLine = linesInFile[line++];
//if(IsTransposeArrayHeaderLine(s,&numPts)) //
if(IsTransposeArrayHeaderLine(currentLine,numPts)) //
{
//if (err = ReadTransposeArray(f,&line,&fVerdatToNetCDFH,numPts,errmsg))
if (err = ReadTransposeArray(linesInFile,&line,&fVerdatToNetCDFH,numPts,errmsg))
{strcpy(errmsg,"Error in ReadTransposeArray"); goto done;}
}
else {err=-1; strcpy(errmsg,"Error in Transpose header line"); goto done;}
//if(err = ReadTVertices(f,&line,&pts,&depths,errmsg)) goto done;
if(err = ReadTVertices(linesInFile,&line,&pts,&depths,errmsg)) goto done;
if(pts)
{
LongPoint thisLPoint;
numPts = _GetHandleSize((Handle)pts)/sizeof(LongPoint);
if(numPts > 0)
{
WorldPoint wp;
for(i=0;i<numPts;i++)
{
thisLPoint = INDEXH(pts,i);
wp.pLat = thisLPoint.v;
wp.pLong = thisLPoint.h;
AddWPointToWRect(wp.pLat, wp.pLong, &bounds);
}
}
}
MySpinCursor();
currentLine = linesInFile[line++];
//NthLineInTextOptimized(*f, (line)++, s, 1024);
//code goes here, boundary points
//if(IsBoundarySegmentHeaderLine(s,&numBoundarySegs)) // Boundary data from CATs
if(IsBoundarySegmentHeaderLine(currentLine,numBoundarySegs)) // Boundary data from CATs
{
MySpinCursor();
if (numBoundarySegs>0)
//err = ReadBoundarySegs(f,&line,&boundarySegs,numBoundarySegs,errmsg);
err = ReadBoundarySegs(linesInFile,&line,&boundarySegs,numBoundarySegs,errmsg);
if(err) goto done;
//NthLineInTextOptimized(*f, (line)++, s, 1024);
currentLine = linesInFile[line++];
}
else
{
//err = -1;
//strcpy(errmsg,"Error in Boundary segment header line");
//goto done;
// not needed for 2D files, but we require for now
}
MySpinCursor(); // JLM 8/4/99
//if(IsWaterBoundaryHeaderLine(s,&numWaterBoundaries,&numBoundaryPts)) // Boundary types from CATs
if(IsWaterBoundaryHeaderLine(currentLine,numWaterBoundaries,numBoundaryPts)) // Boundary types from CATs
{
MySpinCursor();
if (numBoundaryPts>0)
//err = ReadWaterBoundaries(f,&line,&waterBoundaries,numWaterBoundaries,numBoundaryPts,errmsg);
err = ReadWaterBoundaries(linesInFile,&line,&waterBoundaries,numWaterBoundaries,numBoundaryPts,errmsg);
if(err) goto done;
//NthLineInTextOptimized(*f, (line)++, s, 1024);
currentLine = linesInFile[line++];
}
else
{
//err = -1;
//strcpy(errmsg,"Error in Water boundaries header line");
//goto done;
// not needed for 2D files, but we require for now
}
MySpinCursor(); // JLM 8/4/99
//NthLineInTextOptimized(*f, (line)++, s, 1024);
//if(IsBoundaryPointsHeaderLine(s,&numBoundaryPts)) // Boundary data from CATs
if(IsBoundaryPointsHeaderLine(currentLine,numBoundaryPts)) // Boundary data from CATs
{
MySpinCursor();
if (numBoundaryPts>0)
//err = ReadBoundaryPts(f,&line,&boundaryPts,numBoundaryPts,errmsg);
err = ReadBoundaryPts(linesInFile,&line,&boundaryPts,numBoundaryPts,errmsg);
if(err) goto done;
//NthLineInTextOptimized(*f, (line)++, s, 1024);
currentLine = linesInFile[line++];
}
else
{
//err = -1;
//strcpy(errmsg,"Error in Boundary segment header line");
//goto done;
// not always needed ? probably always needed for curvilinear
}
MySpinCursor(); // JLM 8/4/99
//if(IsTTopologyHeaderLine(s,&numTopoPoints)) // Topology from CATs
if(IsTTopologyHeaderLine(currentLine,numTopoPoints)) // Topology from CATs
{
MySpinCursor();
//err = ReadTTopologyBody(f,&line,&topo,&velH,errmsg,numTopoPoints,FALSE);
err = ReadTTopologyBody(linesInFile,&line,&topo,&velH,errmsg,numTopoPoints,FALSE);
if(err) goto done;
//NthLineInTextOptimized(*f, (line)++, s, 1024);
currentLine = linesInFile[line++];
}
else
{
err = -1; // for now we require TTopology
strcpy(errmsg,"Error in topology header line");
if(err) goto done;
}
MySpinCursor(); // JLM 8/4/99
//NthLineInTextOptimized(*f, (line)++, s, 1024);
//if(IsTIndexedDagTreeHeaderLine(s,&numPoints)) // DagTree from CATs
if(IsTIndexedDagTreeHeaderLine(currentLine,numPoints)) // DagTree from CATs
{
MySpinCursor();
//err = ReadTIndexedDagTreeBody(f,&line,&tree,errmsg,numPoints);
err = ReadTIndexedDagTreeBody(linesInFile,&line,&tree,errmsg,numPoints);
if(err) goto done;
}
else
{
err = -1; // for now we require TIndexedDagTree
strcpy(errmsg,"Error in dag tree header line");
if(err) goto done;
}
MySpinCursor(); // JLM 8/4/99
/////////////////////////////////////////////////
// if the boundary information is in the file we'll need to create a bathymetry map (required for 3D)
/*if (waterBoundaries && (this -> moverMap == model -> uMap))
{
//PtCurMap *map = CreateAndInitPtCurMap(fVar.userName,bounds); // the map bounds are the same as the grid bounds
PtCurMap *map = CreateAndInitPtCurMap("Extended Topology",bounds); // the map bounds are the same as the grid bounds
if (!map) {strcpy(errmsg,"Error creating ptcur map"); goto done;}
// maybe move up and have the map read in the boundary information
map->SetBoundarySegs(boundarySegs);
map->SetWaterBoundaries(waterBoundaries);
*newMap = map;
}*/
{ // wind will always be on another map
if (waterBoundaries) {DisposeHandle((Handle)waterBoundaries); waterBoundaries=0;}
if (boundarySegs) {DisposeHandle((Handle)boundarySegs); boundarySegs=0;}
if (boundaryPts) {DisposeHandle((Handle)boundaryPts); boundaryPts=0;}
}
/*if (!(this -> moverMap == model -> uMap)) // maybe assume rectangle grids will have map?
{
if (waterBoundaries) {DisposeHandle((Handle)waterBoundaries); waterBoundaries=0;}
if (boundarySegs) {DisposeHandle((Handle)boundarySegs); boundarySegs=0;}
}*/
/////////////////////////////////////////////////
triGrid = new TTriGridVel;
if (!triGrid)
{
err = true;
TechError("Error in NetCDFWindMover::ReadTopology()","new TTriGridVel" ,err);
goto done;
}
fGrid = (TTriGridVel*)triGrid;
triGrid -> SetBounds(bounds);
//triGrid -> SetDepths(depths);
dagTree = new TDagTree(pts,topo,tree.treeHdl,velH,tree.numBranches);
if(!dagTree)
{
err = -1;
printError("Unable to read Extended Topology file.");
goto done;
}
triGrid -> SetDagTree(dagTree);
pts = 0; // because fGrid is now responsible for it
topo = 0; // because fGrid is now responsible for it
tree.treeHdl = 0; // because fGrid is now responsible for it
velH = 0; // because fGrid is now responsible for it
//depths = 0;
done:
if(depths) {DisposeHandle((Handle)depths); depths=0;}
/*if(f)
{
_HUnlock((Handle)f);
DisposeHandle((Handle)f);
f = 0;
}*/
if(err)
{
if(!errmsg[0])
strcpy(errmsg,"An error occurred in NetCDFWindMoverCurv::ReadTopology");
printError(errmsg);
if(pts) {DisposeHandle((Handle)pts); pts=0;}
if(topo) {DisposeHandle((Handle)topo); topo=0;}
if(velH) {DisposeHandle((Handle)velH); velH=0;}
if(depths) {DisposeHandle((Handle)depths); depths=0;}
if(tree.treeHdl) {DisposeHandle((Handle)tree.treeHdl); tree.treeHdl=0;}
if(fGrid)
{
fGrid ->Dispose();
delete fGrid;
fGrid = 0;
}
if (*newMap)
{
(*newMap)->Dispose();
delete *newMap;
*newMap=0;
}
if (waterBoundaries) {DisposeHandle((Handle)waterBoundaries); waterBoundaries=0;}
if (boundarySegs) {DisposeHandle((Handle)boundarySegs); boundarySegs = 0;}
if (boundaryPts) {DisposeHandle((Handle)boundaryPts); boundaryPts = 0;}
}
return err;
}
// simplify for wind data - no map needed, no mask
OSErr NetCDFWindMoverCurv_c::ReorderPoints(TMap **newMap, char* errmsg)
{
long i, j, n, ntri, numVerdatPts=0;
long fNumRows_ext = fNumRows+1, fNumCols_ext = fNumCols+1;
long nv = fNumRows * fNumCols, nv_ext = fNumRows_ext*fNumCols_ext;
long iIndex, jIndex, index;
long triIndex1, triIndex2, waterCellNum=0;
long ptIndex = 0, cellNum = 0;
long indexOfStart = 0;
OSErr err = 0;
LONGH landWaterInfo = (LONGH)_NewHandleClear(fNumRows * fNumCols * sizeof(long));
LONGH maskH2 = (LONGH)_NewHandleClear(nv_ext * sizeof(long));
LONGH ptIndexHdl = (LONGH)_NewHandleClear(nv_ext * sizeof(**ptIndexHdl));
LONGH verdatPtsH = (LONGH)_NewHandleClear(nv_ext * sizeof(**verdatPtsH));
GridCellInfoHdl gridCellInfo = (GridCellInfoHdl)_NewHandleClear(nv * sizeof(**gridCellInfo));
TopologyHdl topo=0;
LongPointHdl pts=0;
VelocityFH velH = 0;
DAGTreeStruct tree;
WorldRect triBounds;
TTriGridVel *triGrid = nil;
tree.treeHdl = 0;
TDagTree *dagTree = 0;
VelocityFH velocityH = 0;
if (!landWaterInfo || !ptIndexHdl || !gridCellInfo || !verdatPtsH || !maskH2) {err = memFullErr; goto done;}
err = ReadTimeData(indexOfStart,&velocityH,errmsg); // try to use velocities to set grid
for (i=0;i<fNumRows;i++)
{
for (j=0;j<fNumCols;j++)
{
// eventually will need to have a land mask, for now assume fillValue represents land
//if (INDEXH(velocityH,i*fNumCols+j).u==0 && INDEXH(velocityH,i*fNumCols+j).v==0) // land point
if (INDEXH(velocityH,i*fNumCols+j).u==fFillValue && INDEXH(velocityH,i*fNumCols+j).v==fFillValue) // land point
{
INDEXH(landWaterInfo,i*fNumCols+j) = -1; // may want to mark each separate island with a unique number
}
else
{
INDEXH(landWaterInfo,i*fNumCols+j) = 1;
INDEXH(ptIndexHdl,i*fNumCols_ext+j) = -2; // water box
INDEXH(ptIndexHdl,i*fNumCols_ext+j+1) = -2;
INDEXH(ptIndexHdl,(i+1)*fNumCols_ext+j) = -2;
INDEXH(ptIndexHdl,(i+1)*fNumCols_ext+j+1) = -2;
}
}
}
for (i=0;i<fNumRows_ext;i++)
{
for (j=0;j<fNumCols_ext;j++)
{
if (INDEXH(ptIndexHdl,i*fNumCols_ext+j) == -2)
{
INDEXH(ptIndexHdl,i*fNumCols_ext+j) = ptIndex; // count up grid points
ptIndex++;
}
else
INDEXH(ptIndexHdl,i*fNumCols_ext+j) = -1;
}
}
for (i=0;i<fNumRows;i++)
{
for (j=0;j<fNumCols;j++)
{
if (INDEXH(landWaterInfo,i*fNumCols+j)>0)
{
INDEXH(gridCellInfo,i*fNumCols+j).cellNum = cellNum;
cellNum++;
INDEXH(gridCellInfo,i*fNumCols+j).topLeft = INDEXH(ptIndexHdl,i*fNumCols_ext+j);
INDEXH(gridCellInfo,i*fNumCols+j).topRight = INDEXH(ptIndexHdl,i*fNumCols_ext+j+1);
INDEXH(gridCellInfo,i*fNumCols+j).bottomLeft = INDEXH(ptIndexHdl,(i+1)*fNumCols_ext+j);
INDEXH(gridCellInfo,i*fNumCols+j).bottomRight = INDEXH(ptIndexHdl,(i+1)*fNumCols_ext+j+1);
}
else INDEXH(gridCellInfo,i*fNumCols+j).cellNum = -1;
}
}
ntri = cellNum*2; // each water cell is split into two triangles
if(!(topo = (TopologyHdl)_NewHandleClear(ntri * sizeof(Topology)))){err = memFullErr; goto done;}
for (i=0;i<nv_ext;i++)
{
if (INDEXH(ptIndexHdl,i) != -1)
{
INDEXH(verdatPtsH,numVerdatPts) = i;
//INDEXH(verdatPtsH,INDEXH(ptIndexHdl,i)) = i;
numVerdatPts++;
}
}
_SetHandleSize((Handle)verdatPtsH,numVerdatPts*sizeof(**verdatPtsH));
pts = (LongPointHdl)_NewHandle(sizeof(LongPoint)*(numVerdatPts));
if(pts == nil)
{
strcpy(errmsg,"Not enough memory to triangulate data.");
return -1;
}
for (i=0; i<=numVerdatPts; i++) // make a list of grid points that will be used for triangles
{
float fLong, fLat, fDepth, dLon, dLat, dLon1, dLon2, dLat1, dLat2;
//double val, u=0., v=0.;
LongPoint vertex;
if(i < numVerdatPts)
{ // since velocities are defined at the lower left corner of each grid cell
// need to add an extra row/col at the top/right of the grid
// set lat/lon based on distance between previous two points
// these are just for boundary/drawing purposes, velocities are set to zero
index = i+1;
n = INDEXH(verdatPtsH,i);
iIndex = n/fNumCols_ext;
jIndex = n%fNumCols_ext;
if (iIndex==0)
{
if (jIndex<fNumCols)
{
dLat = INDEXH(fVertexPtsH,fNumCols+jIndex).pLat - INDEXH(fVertexPtsH,jIndex).pLat;
fLat = INDEXH(fVertexPtsH,jIndex).pLat - dLat;
dLon = INDEXH(fVertexPtsH,fNumCols+jIndex).pLong - INDEXH(fVertexPtsH,jIndex).pLong;
fLong = INDEXH(fVertexPtsH,jIndex).pLong - dLon;
}
else
{
dLat1 = (INDEXH(fVertexPtsH,jIndex-1).pLat - INDEXH(fVertexPtsH,jIndex-2).pLat);
dLat2 = INDEXH(fVertexPtsH,fNumCols+jIndex-1).pLat - INDEXH(fVertexPtsH,fNumCols+jIndex-2).pLat;
fLat = 2*(INDEXH(fVertexPtsH,jIndex-1).pLat + dLat1)-(INDEXH(fVertexPtsH,fNumCols+jIndex-1).pLat+dLat2);
dLon1 = INDEXH(fVertexPtsH,fNumCols+jIndex-1).pLong - INDEXH(fVertexPtsH,jIndex-1).pLong;
dLon2 = (INDEXH(fVertexPtsH,fNumCols+jIndex-2).pLong - INDEXH(fVertexPtsH,jIndex-2).pLong);
fLong = 2*(INDEXH(fVertexPtsH,jIndex-1).pLong-dLon1)-(INDEXH(fVertexPtsH,jIndex-2).pLong-dLon2);
}
}
else
{
if (jIndex<fNumCols)
{
fLat = INDEXH(fVertexPtsH,(iIndex-1)*fNumCols+jIndex).pLat;
fLong = INDEXH(fVertexPtsH,(iIndex-1)*fNumCols+jIndex).pLong;
//u = INDEXH(velocityH,(iIndex-1)*fNumCols+jIndex).u;
//v = INDEXH(velocityH,(iIndex-1)*fNumCols+jIndex).v;
}
else
{
dLat = INDEXH(fVertexPtsH,(iIndex-1)*fNumCols+jIndex-1).pLat - INDEXH(fVertexPtsH,(iIndex-1)*fNumCols+jIndex-2).pLat;
fLat = INDEXH(fVertexPtsH,(iIndex-1)*fNumCols+jIndex-1).pLat + dLat;
dLon = INDEXH(fVertexPtsH,(iIndex-1)*fNumCols+jIndex-1).pLong - INDEXH(fVertexPtsH,(iIndex-1)*fNumCols+jIndex-2).pLong;
fLong = INDEXH(fVertexPtsH,(iIndex-1)*fNumCols+jIndex-1).pLong + dLon;
}
}
vertex.v = (long)(fLat*1e6);
vertex.h = (long)(fLong*1e6);
fDepth = 1.;
INDEXH(pts,i) = vertex;
}
else { // for outputting a verdat the last line should be all zeros
index = 0;
fLong = fLat = fDepth = 0.0;
}
/////////////////////////////////////////////////
}
// figure out the bounds
triBounds = voidWorldRect;
if(pts)
{
LongPoint thisLPoint;
if(numVerdatPts > 0)
{
WorldPoint wp;
for(i=0;i<numVerdatPts;i++)
{
thisLPoint = INDEXH(pts,i);
wp.pLat = thisLPoint.v;
wp.pLong = thisLPoint.h;
AddWPointToWRect(wp.pLat, wp.pLong, &triBounds);
}
}
}
DisplayMessage("NEXTMESSAGETEMP");
DisplayMessage("Making Triangles");
/////////////////////////////////////////////////
for (i=0;i<fNumRows;i++)
{
for (j=0;j<fNumCols;j++)
{
if (INDEXH(landWaterInfo,i*fNumCols+j)==-1)
continue;
waterCellNum = INDEXH(gridCellInfo,i*fNumCols+j).cellNum; // split each cell into 2 triangles
triIndex1 = 2*waterCellNum;
triIndex2 = 2*waterCellNum+1;
// top/left tri in rect
(*topo)[triIndex1].vertex1 = INDEXH(gridCellInfo,i*fNumCols+j).topRight;
(*topo)[triIndex1].vertex2 = INDEXH(gridCellInfo,i*fNumCols+j).topLeft;
(*topo)[triIndex1].vertex3 = INDEXH(gridCellInfo,i*fNumCols+j).bottomLeft;
if (j==0 || INDEXH(gridCellInfo,i*fNumCols+j-1).cellNum == -1)
(*topo)[triIndex1].adjTri1 = -1;
else
{
(*topo)[triIndex1].adjTri1 = INDEXH(gridCellInfo,i*fNumCols+j-1).cellNum * 2 + 1;
}
(*topo)[triIndex1].adjTri2 = triIndex2;
if (i==0 || INDEXH(gridCellInfo,(i-1)*fNumCols+j).cellNum==-1)
(*topo)[triIndex1].adjTri3 = -1;
else
{
(*topo)[triIndex1].adjTri3 = INDEXH(gridCellInfo,(i-1)*fNumCols+j).cellNum * 2 + 1;
}
// bottom/right tri in rect
(*topo)[triIndex2].vertex1 = INDEXH(gridCellInfo,i*fNumCols+j).bottomLeft;
(*topo)[triIndex2].vertex2 = INDEXH(gridCellInfo,i*fNumCols+j).bottomRight;
(*topo)[triIndex2].vertex3 = INDEXH(gridCellInfo,i*fNumCols+j).topRight;
if (j==fNumCols-1 || INDEXH(gridCellInfo,i*fNumCols+j+1).cellNum == -1)
(*topo)[triIndex2].adjTri1 = -1;
else
{
(*topo)[triIndex2].adjTri1 = INDEXH(gridCellInfo,i*fNumCols+j+1).cellNum * 2;
}
(*topo)[triIndex2].adjTri2 = triIndex1;
if (i==fNumRows-1 || INDEXH(gridCellInfo,(i+1)*fNumCols+j).cellNum == -1)
(*topo)[triIndex2].adjTri3 = -1;
else
{
(*topo)[triIndex2].adjTri3 = INDEXH(gridCellInfo,(i+1)*fNumCols+j).cellNum * 2;
}
}
}
DisplayMessage("NEXTMESSAGETEMP");
DisplayMessage("Making Dag Tree");
MySpinCursor(); // JLM 8/4/99
tree = MakeDagTree(topo, (LongPoint**)pts, errmsg);
MySpinCursor(); // JLM 8/4/99
if (errmsg[0])
{err = -1; goto done;}
// sethandle size of the fTreeH to be tree.fNumBranches, the rest are zeros
_SetHandleSize((Handle)tree.treeHdl,tree.numBranches*sizeof(DAG));
/////////////////////////////////////////////////
fVerdatToNetCDFH = verdatPtsH;
/////////////////////////////////////////////////
triGrid = new TTriGridVel;
if (!triGrid)
{
err = true;
TechError("Error in NetCDFWindMoverCurv::ReorderPoints()","new TTriGridVel",err);
goto done;
}
fGrid = (TTriGridVel*)triGrid;
triGrid -> SetBounds(triBounds);
dagTree = new TDagTree(pts,topo,tree.treeHdl,velH,tree.numBranches);
if(!dagTree)
{
err = -1;
printError("Unable to create dag tree.");
goto done;
}
triGrid -> SetDagTree(dagTree);
//triGrid -> SetDepths(totalDepthH); // used by PtCurMap to check vertical movement
pts = 0; // because fGrid is now responsible for it
topo = 0; // because fGrid is now responsible for it
velH = 0; // because fGrid is now responsible for it
tree.treeHdl = 0; // because fGrid is now responsible for it
velH = 0; // because fGrid is now responsible for it
/////////////////////////////////////////////////
done:
if (landWaterInfo) {DisposeHandle((Handle)landWaterInfo); landWaterInfo=0;}
if (ptIndexHdl) {DisposeHandle((Handle)ptIndexHdl); ptIndexHdl = 0;}
if (gridCellInfo) {DisposeHandle((Handle)gridCellInfo); gridCellInfo = 0;}
if(err)
{
if(!errmsg[0])
strcpy(errmsg,"An error occurred in NetCDFWindMoverCurv::ReorderPoints");
printError(errmsg);
if(pts) {DisposeHandle((Handle)pts); pts=0;}
if(topo) {DisposeHandle((Handle)topo); topo=0;}
if(velH) {DisposeHandle((Handle)velH); velH=0;}
if(tree.treeHdl) {DisposeHandle((Handle)tree.treeHdl); tree.treeHdl=0;}
if(fGrid)
{
fGrid ->Dispose();
delete fGrid;
fGrid = 0;
}
if (verdatPtsH) {DisposeHandle((Handle)verdatPtsH); verdatPtsH = 0;}
if (maskH2) {DisposeHandle((Handle)maskH2); maskH2 = 0;}
}
if (velocityH) {DisposeHandle((Handle)velocityH); velocityH = 0;}
return err;
}