int OutCoreInterp::outputFile(char *outputName, int outputFormat, unsigned int outputType)
{
int i, j, k, l;
FILE **arcFiles;
char arcFileName[1024];
FILE **gridFiles;
char gridFileName[1024];
char *ext[5] = {".min", ".max", ".mean", ".idw", ".den"};
unsigned int type[5] = {OUTPUT_TYPE_MIN, OUTPUT_TYPE_MAX, OUTPUT_TYPE_MEAN, OUTPUT_TYPE_IDW, OUTPUT_TYPE_DEN};
int numTypes = 5;
// open ArcGIS files
if(outputFormat == OUTPUT_FORMAT_ARC_ASCII || outputFormat == OUTPUT_FORMAT_ALL)
{
if((arcFiles = (FILE **)malloc(sizeof(FILE *) * numTypes)) == NULL)
{
cout << "Arc File open error: " << endl;
return -1;
}
for(i = 0; i < numTypes; i++)
{
if(outputType & type[i])
{
strncpy(arcFileName, outputName, sizeof(arcFileName));
strncat(arcFileName, ext[i], strlen(ext[i]));
strncat(arcFileName, ".asc", strlen(".asc"));
if((arcFiles[i] = fopen64(arcFileName, "w+")) == NULL)
{
cout << "File open error: " << arcFileName << endl;
return -1;
}
}else{
arcFiles[i] = NULL;
}
}
} else {
arcFiles = NULL;
}
// open Grid ASCII files
if(outputFormat == OUTPUT_FORMAT_GRID_ASCII || outputFormat == OUTPUT_FORMAT_ALL)
{
if((gridFiles = (FILE **)malloc(sizeof(FILE *) * numTypes)) == NULL)
{
cout << "File array allocation error" << endl;
return -1;
}
for(i = 0; i < numTypes; i++)
{
if(outputType & type[i])
{
strncpy(gridFileName, outputName, sizeof(arcFileName));
strncat(gridFileName, ext[i], strlen(ext[i]));
strncat(gridFileName, ".grid", strlen(".grid"));
if((gridFiles[i] = fopen64(gridFileName, "w+")) == NULL)
{
cout << "File open error: " << gridFileName << endl;
return -1;
}
}else{
gridFiles[i] = NULL;
}
}
} else {
gridFiles = NULL;
}
// print ArcGIS headers
if(arcFiles != NULL)
{
for(i = 0; i < numTypes; i++)
{
if(arcFiles[i] != NULL)
{
fprintf(arcFiles[i], "ncols %d\n", GRID_SIZE_X);
fprintf(arcFiles[i], "nrows %d\n", GRID_SIZE_Y);
fprintf(arcFiles[i], "xllcorner %f\n", min_x);
fprintf(arcFiles[i], "yllcorner %f\n", min_y);
fprintf(arcFiles[i], "cellsize %f\n", GRID_DIST_X);
fprintf(arcFiles[i], "NODATA_value -9999\n");
}
}
}
// print Grid headers
if(gridFiles != NULL)
{
for(i = 0; i < numTypes; i++)
{
if(gridFiles[i] != NULL)
{
fprintf(gridFiles[i], "north: %f\n", max_y);
fprintf(gridFiles[i], "south: %f\n", min_y);
fprintf(gridFiles[i], "east: %f\n", max_x);
fprintf(gridFiles[i], "west: %f\n", min_x);
fprintf(gridFiles[i], "rows: %d\n", GRID_SIZE_Y);
fprintf(gridFiles[i], "cols: %d\n", GRID_SIZE_X);
}
}
}
for(i = numFiles -1; i >= 0; i--)
{
GridFile *gf = gridMap[i]->getGridFile();
gf->map();
int start = gridMap[i]->getLowerBound() - gridMap[i]->getOverlapLowerBound();
int end = gridMap[i]->getUpperBound() - gridMap[i]->getOverlapLowerBound() + 1;
//int start = (gridMap[i]->getLowerBound() - gridMap[i]->getOverlapLowerBound()) * GRID_SIZE_X;
//int end = (gridMap[i]->getUpperBound() - gridMap[i]->getOverlapLowerBound() + 1) * GRID_SIZE_X;
cout << "Merging " << i << ": from " << (start) << " to " << (end) << endl;
cout << " " << i << ": from " << (start/GRID_SIZE_X) << " to " << (end/GRID_SIZE_X) << endl;
for(j = end - 1; j >= start; j--)
{
for(k = 0; k < GRID_SIZE_X; k++)
{
int index = j * GRID_SIZE_X + k;
if(arcFiles != NULL)
{
// Zmin
if(arcFiles[0] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
//if(gf->interp[k][j].Zmin == 0)
fprintf(arcFiles[0], "-9999 ");
else
//fprintf(arcFiles[0], "%f ", gf->interp[j][i].Zmin);
fprintf(arcFiles[0], "%f ", gf->interp[index].Zmin);
}
// Zmax
if(arcFiles[1] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(arcFiles[1], "-9999 ");
else
fprintf(arcFiles[1], "%f ", gf->interp[index].Zmax);
}
// Zmean
if(arcFiles[2] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(arcFiles[2], "-9999 ");
else
fprintf(arcFiles[2], "%f ", gf->interp[index].Zmean);
}
// Zidw
if(arcFiles[3] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(arcFiles[3], "-9999 ");
else
fprintf(arcFiles[3], "%f ", gf->interp[index].Zidw);
}
// count
if(arcFiles[4] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(arcFiles[4], "-9999 ");
else
fprintf(arcFiles[4], "%d ", gf->interp[index].count);
}
}
if(gridFiles != NULL)
{
// Zmin
if(gridFiles[0] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(gridFiles[0], "-9999 ");
else
fprintf(gridFiles[0], "%f ", gf->interp[index].Zmin);
}
// Zmax
if(gridFiles[1] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(gridFiles[1], "-9999 ");
else
fprintf(gridFiles[1], "%f ", gf->interp[index].Zmax);
}
// Zmean
if(gridFiles[2] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(gridFiles[2], "-9999 ");
else
fprintf(gridFiles[2], "%f ", gf->interp[index].Zmean);
}
// Zidw
if(gridFiles[3] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(gridFiles[3], "-9999 ");
else
fprintf(gridFiles[3], "%f ", gf->interp[index].Zidw);
}
// count
if(gridFiles[4] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(gridFiles[4], "-9999 ");
else
fprintf(gridFiles[4], "%d ", gf->interp[index].count);
}
}
}
if(arcFiles != NULL)
for(l = 0; l < numTypes; l++)
{
if(arcFiles[l] != NULL)
fprintf(arcFiles[l], "\n");
}
if(gridFiles != NULL)
for(l = 0; l < numTypes; l++)
{
if(gridFiles[l] != NULL)
fprintf(gridFiles[l], "\n");
}
}
gf->unmap();
}
// close files
if(gridFiles != NULL)
{
for(i = 0; i < numTypes; i++)
{
if(gridFiles[i] != NULL)
fclose(gridFiles[i]);
}
}
if(arcFiles != NULL)
{
for(i = 0; i < numTypes; i++)
{
if(arcFiles[i] != NULL)
fclose(arcFiles[i]);
}
}
return 0;
}
int OutCoreInterp::outputFile(char *outputName, int outputFormat, unsigned int outputType, double *adfGeoTransform, const char* wkt)
{
int i, j, k, l, t;
FILE **arcFiles;
char arcFileName[1024];
FILE **gridFiles;
char gridFileName[1024];
const char *ext[6] = {".min", ".max", ".mean", ".idw", ".den", ".std"};
unsigned int type[6] = {OUTPUT_TYPE_MIN, OUTPUT_TYPE_MAX, OUTPUT_TYPE_MEAN, OUTPUT_TYPE_IDW, OUTPUT_TYPE_DEN, OUTPUT_TYPE_STD};
int numTypes = 6;
// open ArcGIS files
if(outputFormat == OUTPUT_FORMAT_ARC_ASCII || outputFormat == OUTPUT_FORMAT_ALL)
{
if((arcFiles = (FILE **)malloc(sizeof(FILE *) * numTypes)) == NULL)
{
cerr << "Arc File open error: " << endl;
return -1;
}
for(i = 0; i < numTypes; i++)
{
if(outputType & type[i])
{
strncpy(arcFileName, outputName, sizeof(arcFileName));
strncat(arcFileName, ext[i], strlen(ext[i]));
strncat(arcFileName, ".asc", strlen(".asc"));
if((arcFiles[i] = fopen(arcFileName, "w+")) == NULL)
{
cerr << "File open error: " << arcFileName << endl;
return -1;
}
} else {
arcFiles[i] = NULL;
}
}
} else {
arcFiles = NULL;
}
// open Grid ASCII files
if(outputFormat == OUTPUT_FORMAT_GRID_ASCII || outputFormat == OUTPUT_FORMAT_ALL)
{
if((gridFiles = (FILE **)malloc(sizeof(FILE *) * numTypes)) == NULL)
{
cerr << "File array allocation error" << endl;
return -1;
}
for(i = 0; i < numTypes; i++)
{
if(outputType & type[i])
{
strncpy(gridFileName, outputName, sizeof(arcFileName));
strncat(gridFileName, ext[i], strlen(ext[i]));
strncat(gridFileName, ".grid", strlen(".grid"));
if((gridFiles[i] = fopen(gridFileName, "w+")) == NULL)
{
cerr << "File open error: " << gridFileName << endl;
return -1;
}
} else {
gridFiles[i] = NULL;
}
}
} else {
gridFiles = NULL;
}
// print ArcGIS headers
if(arcFiles != NULL)
{
for(i = 0; i < numTypes; i++)
{
if(arcFiles[i] != NULL)
{
fprintf(arcFiles[i], "ncols %d\n", GRID_SIZE_X);
fprintf(arcFiles[i], "nrows %d\n", GRID_SIZE_Y);
fprintf(arcFiles[i], "xllcorner %f\n", min_x);
fprintf(arcFiles[i], "yllcorner %f\n", min_y);
fprintf(arcFiles[i], "cellsize %f\n", GRID_DIST_X);
fprintf(arcFiles[i], "NODATA_value -9999\n");
}
}
}
// print Grid headers
if(gridFiles != NULL)
{
for(i = 0; i < numTypes; i++)
{
if(gridFiles[i] != NULL)
{
fprintf(gridFiles[i], "north: %f\n", max_y);
fprintf(gridFiles[i], "south: %f\n", min_y);
fprintf(gridFiles[i], "east: %f\n", max_x);
fprintf(gridFiles[i], "west: %f\n", min_x);
fprintf(gridFiles[i], "rows: %d\n", GRID_SIZE_Y);
fprintf(gridFiles[i], "cols: %d\n", GRID_SIZE_X);
}
}
}
for(i = numFiles -1; i >= 0; i--)
{
GridFile *gf = gridMap[i]->getGridFile();
gf->map();
int start = gridMap[i]->getLowerBound() - gridMap[i]->getOverlapLowerBound();
int end = gridMap[i]->getUpperBound() - gridMap[i]->getOverlapLowerBound() + 1;
//int start = (gridMap[i]->getLowerBound() - gridMap[i]->getOverlapLowerBound()) * GRID_SIZE_X;
//int end = (gridMap[i]->getUpperBound() - gridMap[i]->getOverlapLowerBound() + 1) * GRID_SIZE_X;
cerr << "Merging " << i << ": from " << (start) << " to " << (end) << endl;
cerr << " " << i << ": from " << (start/GRID_SIZE_X) << " to " << (end/GRID_SIZE_X) << endl;
for(j = end - 1; j >= start; j--)
{
for(k = 0; k < GRID_SIZE_X; k++)
{
int index = j * GRID_SIZE_X + k;
if(arcFiles != NULL)
{
// Zmin
if(arcFiles[0] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
//if(gf->interp[k][j].Zmin == 0)
fprintf(arcFiles[0], "-9999 ");
else
//fprintf(arcFiles[0], "%f ", gf->interp[j][i].Zmin);
fprintf(arcFiles[0], "%f ", gf->interp[index].Zmin);
}
// Zmax
if(arcFiles[1] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(arcFiles[1], "-9999 ");
else
fprintf(arcFiles[1], "%f ", gf->interp[index].Zmax);
}
// Zmean
if(arcFiles[2] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(arcFiles[2], "-9999 ");
else
fprintf(arcFiles[2], "%f ", gf->interp[index].Zmean);
}
// Zidw
if(arcFiles[3] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(arcFiles[3], "-9999 ");
else
fprintf(arcFiles[3], "%f ", gf->interp[index].Zidw);
}
// count
if(arcFiles[4] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(arcFiles[4], "-9999 ");
else
fprintf(arcFiles[4], "%d ", gf->interp[index].count);
}
// Zstd
if(arcFiles[5] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(arcFiles[5], "-9999 ");
else
fprintf(arcFiles[5], "%f ", gf->interp[index].Zstd);
}
}
if(gridFiles != NULL)
{
// Zmin
if(gridFiles[0] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(gridFiles[0], "-9999 ");
else
fprintf(gridFiles[0], "%f ", gf->interp[index].Zmin);
}
// Zmax
if(gridFiles[1] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(gridFiles[1], "-9999 ");
else
fprintf(gridFiles[1], "%f ", gf->interp[index].Zmax);
}
// Zmean
if(gridFiles[2] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(gridFiles[2], "-9999 ");
else
fprintf(gridFiles[2], "%f ", gf->interp[index].Zmean);
}
// Zidw
if(gridFiles[3] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(gridFiles[3], "-9999 ");
else
fprintf(gridFiles[3], "%f ", gf->interp[index].Zidw);
}
// count
if(gridFiles[4] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(gridFiles[4], "-9999 ");
else
fprintf(gridFiles[4], "%d ", gf->interp[index].count);
}
// Zstd
if(gridFiles[5] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(gridFiles[5], "-9999 ");
else
fprintf(gridFiles[5], "%f ", gf->interp[index].Zstd);
}
}
}
if(arcFiles != NULL)
for(l = 0; l < numTypes; l++)
{
if(arcFiles[l] != NULL)
fprintf(arcFiles[l], "\n");
}
if(gridFiles != NULL)
for(l = 0; l < numTypes; l++)
{
if(gridFiles[l] != NULL)
fprintf(gridFiles[l], "\n");
}
}
gf->unmap();
}
#ifdef HAVE_GDAL
GDALDataset **gdalFiles;
char gdalFileName[1024];
// open GDAL GeoTIFF files
if(outputFormat == OUTPUT_FORMAT_GDAL_GTIFF || outputFormat == OUTPUT_FORMAT_ALL)
{
GDALAllRegister();
if((gdalFiles = (GDALDataset **)malloc(sizeof(GDALDataset *) * numTypes)) == NULL)
{
cerr << "File array allocation error" << endl;
return -1;
}
for(i = 0; i < numTypes; i++)
{
if(outputType & type[i])
{
strncpy(gdalFileName, outputName, sizeof(gdalFileName));
strncat(gdalFileName, ext[i], strlen(ext[i]));
strncat(gdalFileName, ".tif", strlen(".tif"));
char **papszMetadata;
const char *pszFormat = "GTIFF";
GDALDriver* tpDriver = GetGDALDriverManager()->GetDriverByName(pszFormat);
if (tpDriver)
{
papszMetadata = tpDriver->GetMetadata();
if (CSLFetchBoolean(papszMetadata, GDAL_DCAP_CREATE, FALSE))
{
char **papszOptions = NULL;
gdalFiles[i] = tpDriver->Create(gdalFileName, GRID_SIZE_X, GRID_SIZE_Y, 1, GDT_Float32, papszOptions);
if (gdalFiles[i] == NULL)
{
cerr << "File open error: " << gdalFileName << endl;
return -1;
} else {
if (adfGeoTransform)
gdalFiles[i]->SetGeoTransform(adfGeoTransform);
if (wkt)
gdalFiles[i]->SetProjection(wkt);
}
}
}
} else {
gdalFiles[i] = NULL;
}
}
} else {
gdalFiles = NULL;
}
if(gdalFiles != NULL)
{
for(t = 0; t < numTypes; t++)
{
if(gdalFiles[t] != NULL)
{
for(i = numFiles -1; i >= 0; i--)
{
GridFile *gf = gridMap[i]->getGridFile();
gf->map();
int start = gridMap[i]->getLowerBound() - gridMap[i]->getOverlapLowerBound();
int end = gridMap[i]->getUpperBound() - gridMap[i]->getOverlapLowerBound() + 1;
cerr << "Merging " << i << ": from " << (start) << " to " << (end) << endl;
cerr << " " << i << ": from " << (start/GRID_SIZE_X) << " to " << (end/GRID_SIZE_X) << endl;
float *poRasterData = new float[GRID_SIZE_X*GRID_SIZE_Y];
for (int j = 0; j < GRID_SIZE_X*GRID_SIZE_Y; j++)
{
poRasterData[j] = 0;
}
for(j = end - 1; j >= start; j--)
{
for(k = 0; k < GRID_SIZE_X; k++)
{
int index = j * GRID_SIZE_X + k;
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
{
poRasterData[index] = -9999.f;
} else {
switch (t)
{
case 0:
poRasterData[index] = gf->interp[index].Zmin;
break;
case 1:
poRasterData[index] = gf->interp[index].Zmax;
break;
case 2:
poRasterData[index] = gf->interp[index].Zmean;
break;
case 3:
poRasterData[index] = gf->interp[index].Zidw;
break;
case 4:
poRasterData[index] = gf->interp[index].count;
break;
case 5:
poRasterData[index] = gf->interp[index].Zstd;
break;
}
}
}
}
GDALRasterBand *tBand = gdalFiles[t]->GetRasterBand(1);
tBand->SetNoDataValue(-9999.f);
if (GRID_SIZE_X > 0 && GRID_SIZE_Y > 0)
tBand->RasterIO(GF_Write, 0, 0, GRID_SIZE_X, GRID_SIZE_Y, poRasterData, GRID_SIZE_X, GRID_SIZE_Y, GDT_Float32, 0, 0);
GDALClose((GDALDatasetH) gdalFiles[t]);
delete [] poRasterData;
}
}
}
}
#endif // HAVE_GDAL
// close files
if(gridFiles != NULL)
{
for(i = 0; i < numTypes; i++)
{
if(gridFiles[i] != NULL)
fclose(gridFiles[i]);
}
}
if(arcFiles != NULL)
{
for(i = 0; i < numTypes; i++)
{
if(arcFiles[i] != NULL)
fclose(arcFiles[i]);
}
}
return 0;
}
int OutCoreInterp::finish(char *outputName, int outputFormat, unsigned int outputType)
{
int i, j;
GridPoint *p;
GridFile *gf;
int len_y;
int offset;
//struct tms tbuf;
clock_t t0, t1;
/*
// managing overlap.
read adjacent blocks and store ghost cells and update the cells
merging multiple files
*/
if(openFile != -1){
gridMap[openFile]->getGridFile()->unmap();
openFile = -1;
}
for(i = 0; i < numFiles; i++)
{
if(qlist[i].size() != 0)
{
if((gf = gridMap[i]->getGridFile()) == NULL)
{
cout << "OutCoreInterp::finish() getGridFile() NULL" << endl;
return -1;
}
gf->map();
openFile = i;
// flush UpdateInfo queue
// pop every update information
list<UpdateInfo>::const_iterator iter;
for(iter = qlist[i].begin(); iter!= qlist[i].end(); iter++){
updateInterpArray(i, (*iter).data_x, (*iter).data_y, (*iter).data_z);
}
qlist[i].erase(qlist[i].begin(), qlist[i].end());
gf->unmap();
openFile = -1;
gf = NULL;
}
}
for(i = 0; i < numFiles - 1; i++)
{
// read the upside overlap
if((gf = gridMap[i]->getGridFile()) == NULL)
{
cout << "OutCoreInterp::finish() getGridFile() NULL" << endl;
return -1;
}
if(gf->map() != -1)
{
openFile = i;
// Sriram's edit to copy over DEM values to overlap also
len_y = 2 * (gridMap[i]->getOverlapUpperBound() - gridMap[i]->getUpperBound() - 1);
if((p = (GridPoint *)malloc(sizeof(GridPoint) * len_y * GRID_SIZE_X)) == NULL)
{
cout << "OutCoreInterp::finish() malloc error" << endl;
return -1;
}
int start = (gridMap[i]->getOverlapUpperBound() - gridMap[i]->getOverlapLowerBound() - len_y) * GRID_SIZE_X;
cout << "copy from " << start << " to " << (start + len_y * GRID_SIZE_X) << endl;
memcpy(p, &(gf->interp[start]), sizeof(GridPoint) * len_y * (GRID_SIZE_X) );
gf->unmap();
gf = NULL;
openFile = -1;
} else {
cout << "OutCoreInterp::finish() gf->map() error" << endl;
return -1;
}
// update (i+1)th component
if((gf = gridMap[i+1]->getGridFile()) == NULL)
{
cout << "OutCoreInterp::finish() getGridFile() NULL" << endl;
return -1;
}
if(gf->map() != -1)
{
offset = 0;
openFile = i - 1;
for(j = 0; j < len_y * GRID_SIZE_X; j++)
{
if(gf->interp[j + offset].Zmin > p[j].Zmin)
gf->interp[j + offset].Zmin = p[j].Zmin;
if(gf->interp[j + offset].Zmax < p[j].Zmax)
gf->interp[j + offset].Zmax = p[j].Zmax;
gf->interp[j + offset].Zmean += p[j].Zmean;
gf->interp[j + offset].count += p[j].count;
if (p[j].sum != -1) {
gf->interp[j + offset].Zidw += p[j].Zidw;
gf->interp[j + offset].sum += p[j].sum;
} else {
gf->interp[j + offset].Zidw = p[j].Zidw;
gf->interp[j + offset].sum = p[j].sum;
}
}
if(p != NULL){
free(p);
p = NULL;
}
gf->unmap();
gf = NULL;
openFile = -1;
} else {
cout << "OutCoreInterp::finish() gf->map() error" << endl;
return -1;
}
}
for(i = numFiles -1; i > 0; i--)
{
// read the downside overlap
if((gf = gridMap[i]->getGridFile()) == NULL)
{
cout << "GridFile is NULL" << endl;
return -1;
}
if(gf->map() != -1)
{
openFile = i;
len_y = 2 * (gridMap[i]->getLowerBound() - gridMap[i]->getOverlapLowerBound());
if((p = (GridPoint *)malloc(sizeof(GridPoint) * len_y * GRID_SIZE_X)) == NULL)
{
cout << "OutCoreInterp::finish() malloc error" << endl;
return -1;
}
memcpy(p, &(gf->interp[0]), len_y * sizeof(GridPoint) * GRID_SIZE_X);
//finalize();
gf->unmap();
gf = NULL;
openFile = -1;
} else {
cout << "OutCoreInterp::finish gf->map() error" << endl;
return -1;
}
// update (i-1)th component
if((gf = gridMap[i-1]->getGridFile()) == NULL)
{
cout << "GridFile is NULL" << endl;
return -1;
}
if(gf->map() != -1)
{
offset = (gridMap[i-1]->getOverlapUpperBound() - gridMap[i-1]->getOverlapLowerBound() - len_y) * GRID_SIZE_X;
openFile = i - 1;
for(j = 0; j < len_y * GRID_SIZE_X; j++)
{
// Sriram - the overlap already contains the correct values
gf->interp[j + offset].Zmin = p[j].Zmin;
gf->interp[j + offset].Zmax = p[j].Zmax;
gf->interp[j + offset].Zmean = p[j].Zmean;
gf->interp[j + offset].count = p[j].count;
gf->interp[j + offset].Zidw = p[j].Zidw;
gf->interp[j + offset].sum = p[j].sum;
}
//if(i - 1 == 0)
//finalize();
if(p != NULL){
free(p);
p = NULL;
}
gf->unmap();
gf = NULL;
openFile = -1;
}
}
for(i = 0; i < numFiles; i++)
{
gridMap[i]->getGridFile()->map();
openFile = i;
finalize();
gridMap[i]->getGridFile()->unmap();
openFile = -1;
}
t0 = clock();
// merge pieces into one file
if(outputFile(outputName, outputFormat, outputType) < 0)
{
cout << "OutCoreInterp::finish outputFile error" << endl;
return -1;
}
t1 = clock();
printf("Output Execution time: %10.2f\n", (double)(t1 - t0)/CLOCKS_PER_SEC);
return 0;
}
int OutCoreInterp::finish(const std::string& outputName, int outputFormat, unsigned int outputType, double *adfGeoTransform, const char* wkt)
{
int i, j;
GridPoint *p;
GridFile *gf;
int len_y;
int offset;
//struct tms tbuf;
clock_t t0, t1;
/*
// managing overlap.
read adjacent blocks and store ghost cells and update the cells
merging multiple files
*/
if(openFile != -1) {
gridMap[openFile]->getGridFile()->unmap();
openFile = -1;
}
////////////////////////////////////////////////////////////
// flushing
// can be moved inside the communications
for(i = 0; i < numFiles; i++)
{
if(qlist[i].size() != 0)
{
if((gf = gridMap[i]->getGridFile()) == NULL)
{
cerr << "OutCoreInterp::finish() getGridFile() NULL" << endl;
return -1;
}
gf->map();
openFile = i;
// flush UpdateInfo queue
// pop every update information
list<UpdateInfo>::const_iterator iter;
for(iter = qlist[i].begin(); iter!= qlist[i].end(); iter++) {
updateInterpArray(i, (*iter).data_x, (*iter).data_y, (*iter).data_z);
}
qlist[i].erase(qlist[i].begin(), qlist[i].end());
gf->unmap();
openFile = -1;
gf = NULL;
}
}
////////////////////////////////////////////////////////////
for(i = 0; i < numFiles - 1; i++)
{
//////////////////////////////////////////////////////////////
// read the upside overlap
if((gf = gridMap[i]->getGridFile()) == NULL)
{
cerr << "OutCoreInterp::finish() getGridFile() NULL" << endl;
return -1;
}
if(gf->map() != -1)
{
openFile = i;
// Sriram's edit to copy over DEM values to overlap also
len_y = 2 * (gridMap[i]->getOverlapUpperBound() - gridMap[i]->getUpperBound() - 1);
if((p = (GridPoint *)malloc(sizeof(GridPoint) * len_y * GRID_SIZE_X)) == NULL)
{
cerr << "OutCoreInterp::finish() malloc error" << endl;
return -1;
}
int start = (gridMap[i]->getOverlapUpperBound() - gridMap[i]->getOverlapLowerBound() - len_y) * GRID_SIZE_X;
cerr << "copy from " << start << " to " << (start + len_y * GRID_SIZE_X) << endl;
memcpy(p, &(gf->interp[start]), sizeof(GridPoint) * len_y * (GRID_SIZE_X) );
gf->unmap();
gf = NULL;
openFile = -1;
} else {
cerr << "OutCoreInterp::finish() gf->map() error" << endl;
return -1;
}
//////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////
// update (i+1)th component
if((gf = gridMap[i+1]->getGridFile()) == NULL)
{
cerr << "OutCoreInterp::finish() getGridFile() NULL" << endl;
return -1;
}
if(gf->map() != -1)
{
offset = 0;
openFile = i - 1;
for(j = 0; j < len_y * GRID_SIZE_X; j++)
{
if(gf->interp[j + offset].Zmin > p[j].Zmin)
gf->interp[j + offset].Zmin = p[j].Zmin;
if(gf->interp[j + offset].Zmax < p[j].Zmax)
gf->interp[j + offset].Zmax = p[j].Zmax;
gf->interp[j + offset].Zmean += p[j].Zmean;
gf->interp[j + offset].count += p[j].count;
/*
// https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Online_algorithm
double delta = p[j].Zstd_tmp - p[j].Zstd_tmp;
gf->interp[j + offset].Zstd_tmp += delta / gf->interp[j + offset].count;
gf->interp[j + offset].Zstd += delta * (
interp[x][y].Zstd += delta * (data_z-interp[x][y].Zstd_tmp);
gf->interp[j + offset].Zstd += p[j].Zstd;
gf->interp[j + offset].Zstd_tmp += p[j].Zstd_tmp;
*/
if (p[j].sum != -1) {
gf->interp[j + offset].Zidw += p[j].Zidw;
gf->interp[j + offset].sum += p[j].sum;
} else {
gf->interp[j + offset].Zidw = p[j].Zidw;
gf->interp[j + offset].sum = p[j].sum;
}
}
if(p != NULL) {
free(p);
p = NULL;
}
gf->unmap();
gf = NULL;
openFile = -1;
} else {
cerr << "OutCoreInterp::finish() gf->map() error" << endl;
return -1;
}
//////////////////////////////////////////////////////////////
}
for(i = numFiles -1; i > 0; i--)
{
//////////////////////////////////////////////////////////////
// read the downside overlap
if((gf = gridMap[i]->getGridFile()) == NULL)
{
cerr << "GridFile is NULL" << endl;
return -1;
}
if(gf->map() != -1)
{
openFile = i;
len_y = 2 * (gridMap[i]->getLowerBound() - gridMap[i]->getOverlapLowerBound());
if((p = (GridPoint *)malloc(sizeof(GridPoint) * len_y * GRID_SIZE_X)) == NULL)
{
cerr << "OutCoreInterp::finish() malloc error" << endl;
return -1;
}
memcpy(p, &(gf->interp[0]), len_y * sizeof(GridPoint) * GRID_SIZE_X);
//finalize();
gf->unmap();
gf = NULL;
openFile = -1;
} else {
cerr << "OutCoreInterp::finish gf->map() error" << endl;
return -1;
}
//////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////
// update (i-1)th component
if((gf = gridMap[i-1]->getGridFile()) == NULL)
{
cerr << "GridFile is NULL" << endl;
return -1;
}
if(gf->map() != -1)
{
offset = (gridMap[i-1]->getOverlapUpperBound() - gridMap[i-1]->getOverlapLowerBound() - len_y) * GRID_SIZE_X;
openFile = i - 1;
for(j = 0; j < len_y * GRID_SIZE_X; j++)
{
// Sriram - the overlap already contains the correct values
gf->interp[j + offset].Zmin = p[j].Zmin;
gf->interp[j + offset].Zmax = p[j].Zmax;
gf->interp[j + offset].Zmean = p[j].Zmean;
gf->interp[j + offset].count = p[j].count;
gf->interp[j + offset].Zidw = p[j].Zidw;
gf->interp[j + offset].sum = p[j].sum;
//gf->interp[j + offset].Zstd = p[j].Zstd;
//gf->interp[j + offset].Zstd_tmp = p[j].Zstd_tmp;
}
//if(i - 1 == 0)
//finalize();
if(p != NULL) {
free(p);
p = NULL;
}
gf->unmap();
gf = NULL;
openFile = -1;
}
//////////////////////////////////////////////////////////////
}
for(i = 0; i < numFiles; i++)
{
gridMap[i]->getGridFile()->map();
openFile = i;
finalize();
gridMap[i]->getGridFile()->unmap();
openFile = -1;
}
t0 = clock();
//t0 = times(&tbuf);
// merge pieces into one file
if(outputFile(outputName, outputFormat, outputType, adfGeoTransform, wkt) < 0)
{
cerr << "OutCoreInterp::finish outputFile error" << endl;
return -1;
}
t1 = clock();
//t1 = times(&tbuf);
cerr << "Output Execution time: " << (double)(t1 - t0)/CLOCKS_PER_SEC << std::endl;
return 0;
}
