/* Matlab Gateway routine */
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
int nXYSize;
double adfGeoTransform[6] = {0,1,0,0,0,1}, adfDstGeoTransform[6];
char *pszSRS_WKT = NULL;
char **papszWarpOptions = NULL;
GDALDatasetH hSrcDS, hDstDS;
GDALDriverH hDriver;
GDALRasterBandH hBand;
GDALColorTableH hColorTable = NULL;
OGRSpatialReference oSrcSRS, oDstSRS;
GDALResampleAlg interpMethod = GRA_NearestNeighbour;
GDALTransformerFunc pfnTransformer = NULL;
CPLErr eErr;
GDAL_GCP *pasGCPs = NULL;
static int runed_once = FALSE; /* It will be set to true if reaches end of main */
const int *dim_array;
int nx, ny, i, j, m, n, c, nBands, registration = 1;
int n_dims, typeCLASS, nBytes;
char *pszSrcSRS = NULL, *pszSrcWKT = NULL;
char *pszDstSRS = NULL, *pszDstWKT = NULL;
void *in_data;
mxArray *mx_ptr;
unsigned char *tmpByte, *outByte;
unsigned short int *tmpUI16, *outUI16;
short int *tmpI16, *outI16;
int *tmpI32, *outI32;
int nPixels=0, nLines=0, nForceWidth=0, nForceHeight=0;
int nGCPCount = 0, nOrder = 0;
unsigned int *tmpUI32, *outUI32;
float *tmpF32, *outF32;
double *tmpF64, *outF64, *ptr_d;
double dfMinX=0, dfMaxX=0, dfMinY=0, dfMaxY=0, dfResX=0, dfResY=0;
double adfExtent[4];
double dfXRes=0.0, dfYRes=0.0;
double dfWarpMemoryLimit = 0.0;
double *pdfDstNodata = NULL;
char **papszMetadataOptions = NULL;
char *tmp, *txt;
if (nrhs == 2 && mxIsStruct(prhs[1])) {
mx_ptr = mxGetField(prhs[1], 0, "ULx");
if (mx_ptr == NULL)
mexErrMsgTxt("GDALWARP 'ULx' field not provided");
ptr_d = mxGetPr(mx_ptr);
adfGeoTransform[0] = *ptr_d;
mx_ptr = mxGetField(prhs[1], 0, "Xinc");
if (mx_ptr == NULL)
mexErrMsgTxt("GDALWARP 'Xinc' field not provided");
ptr_d = mxGetPr(mx_ptr);
adfGeoTransform[1] = *ptr_d;
mx_ptr = mxGetField(prhs[1], 0, "ULy");
if (mx_ptr == NULL)
mexErrMsgTxt("GDALWARP 'ULy' field not provided");
ptr_d = mxGetPr(mx_ptr);
adfGeoTransform[3] = *ptr_d;
mx_ptr = mxGetField(prhs[1], 0, "Yinc");
if (mx_ptr == NULL)
mexErrMsgTxt("GDALWARP 'Yinc' field not provided");
ptr_d = mxGetPr(mx_ptr);
adfGeoTransform[5] = -*ptr_d;
/* -------- See for resolution requests ------------ */
mx_ptr = mxGetField(prhs[1], 0, "t_size");
if (mx_ptr != NULL) {
ptr_d = mxGetPr(mx_ptr);
if (mxGetN(mx_ptr) == 2) {
nForceWidth = (int)ptr_d[0];
nForceHeight = (int)ptr_d[1];
}
else if (mxGetN(mx_ptr) == 1) { /* pick max(nrow,ncol) */
if (mxGetM(prhs[0]) > getNK(prhs[0],1))
nForceHeight = mxGetM(prhs[0]);
else
nForceWidth = getNK(prhs[0], 1);
}
else {
nForceHeight = mxGetM(prhs[0]);
nForceWidth = getNK(prhs[0], 1);
}
}
mx_ptr = mxGetField(prhs[1], 0, "t_res");
if (mx_ptr != NULL) {
ptr_d = mxGetPr(mx_ptr);
if (mxGetN(mx_ptr) == 2) {
dfXRes = ptr_d[0];
dfYRes = ptr_d[1];
}
else if (mxGetN(mx_ptr) == 1) {
dfXRes = dfYRes = ptr_d[0];
}
}
/* -------------------------------------------------- */
/* -------- Change Warping cache size? ------------ */
mx_ptr = mxGetField(prhs[1], 0, "wm");
if (mx_ptr != NULL) {
ptr_d = mxGetPr(mx_ptr);
dfWarpMemoryLimit = *ptr_d * 1024 * 1024;
}
/* -------------------------------------------------- */
/* -------- Have a nodata value order? -------------- */
mx_ptr = mxGetField(prhs[1], 0, "nodata");
if (mx_ptr != NULL) {
pdfDstNodata = mxGetPr(mx_ptr);
}
/* -------------------------------------------------- */
/* -------- See for projection stuff ---------------- */
mx_ptr = mxGetField(prhs[1], 0, "SrcProjSRS");
if (mx_ptr != NULL)
pszSrcSRS = (char *)mxArrayToString(mx_ptr);
mx_ptr = mxGetField(prhs[1], 0, "SrcProjWKT");
if (mx_ptr != NULL)
pszSrcWKT = (char *)mxArrayToString(mx_ptr);
mx_ptr = mxGetField(prhs[1], 0, "DstProjSRS");
if (mx_ptr != NULL)
pszDstSRS = (char *)mxArrayToString(mx_ptr);
mx_ptr = mxGetField(prhs[1], 0, "DstProjWKT");
if (mx_ptr != NULL)
pszDstWKT = (char *)mxArrayToString(mx_ptr);
/* -------------------------------------------------- */
/* -------- Do we have GCPs? ----------------------- */
mx_ptr = mxGetField(prhs[1], 0, "gcp");
if (mx_ptr != NULL) {
nGCPCount = mxGetM(mx_ptr);
if (mxGetN(mx_ptr) != 4)
mexErrMsgTxt("GDALWARP: GCPs must be a Mx4 array");
ptr_d = mxGetPr(mx_ptr);
pasGCPs = (GDAL_GCP *) mxCalloc( nGCPCount, sizeof(GDAL_GCP) );
GDALInitGCPs( 1, pasGCPs + nGCPCount - 1 );
for (i = 0; i < nGCPCount; i++) {
pasGCPs[i].dfGCPPixel = ptr_d[i];
pasGCPs[i].dfGCPLine = ptr_d[i+nGCPCount];
pasGCPs[i].dfGCPX = ptr_d[i+2*nGCPCount];
pasGCPs[i].dfGCPY = ptr_d[i+3*nGCPCount];
pasGCPs[i].dfGCPZ = 0;
}
}
/* ---- Have we an order request? --- */
mx_ptr = mxGetField(prhs[1], 0, "order");
if (mx_ptr != NULL) {
ptr_d = mxGetPr(mx_ptr);
nOrder = (int)*ptr_d;
if (nOrder != -1 || nOrder != 0 || nOrder != 1 || nOrder != 2 || nOrder != 3)
nOrder = 0;
}
/* -------------------------------------------------- */
mx_ptr = mxGetField(prhs[1], 0, "ResampleAlg");
if (mx_ptr != NULL) {
txt = (char *)mxArrayToString(mx_ptr);
if (!strcmp(txt,"nearest"))
interpMethod = GRA_NearestNeighbour;
else if (!strcmp(txt,"bilinear"))
interpMethod = GRA_Bilinear;
else if (!strcmp(txt,"cubic") || !strcmp(txt,"bicubic"))
interpMethod = GRA_Cubic;
else if (!strcmp(txt,"spline"))
interpMethod = GRA_CubicSpline;
}
/* If grid limits were in grid registration, convert them to pixel reg */
mx_ptr = mxGetField(prhs[1], 0, "Reg");
if (mx_ptr != NULL) {
ptr_d = mxGetPr(mx_ptr);
registration = (int)ptr_d[0];
}
if (registration == 0) {
adfGeoTransform[0] -= adfGeoTransform[1]/2.;
adfGeoTransform[3] -= adfGeoTransform[5]/2.;
}
}
else {
mexPrintf("Usage: B = gdalwarp_mex(IMG,HDR_STRUCT)\n\n");
mexPrintf("\tIMG -> is a Mx2 or Mx3 array with an grid/image data to reproject\n");
mexPrintf("\tHDR_STRUCT -> is a structure with the following fields:\n");
mexPrintf("\t\t'ULx' X coordinate of the uper left corner\n");
mexPrintf("\t\t'ULy' Y coordinate of the uper left corner\n");
mexPrintf("\t\t'Xinc' distance between columns in target grid/image coordinates\n");
mexPrintf("\t\t'Yinc' distance between rows in target grid/image coordinates\n");
mexPrintf("\t\t'SrcProjSRS', 'SrcProjWKT' -> Source projection string\n");
mexPrintf("\t\t'DstProjSRS', 'DstProjWKT' -> Target projection string\n");
mexPrintf("\t\t\tSRS stands for a string of the type used by proj4\n");
mexPrintf("\t\t\tWKT stands for a string on the 'Well Known Text' format\n\n");
mexPrintf("\t\t\tIf one of the Src or Dst fields is absent a GEOGRAPHIC WGS84 is assumed\n");
mexPrintf("\nOPTIONS\n");
mexPrintf("\t\t'gcp' a [Mx4] array with Ground Control Points\n");
mexPrintf("\t\t't_size' a [width height] vector to set output file size in pixels\n");
mexPrintf("\t\t't_res' a [xres yres] vector to set output file resolution (in target georeferenced units)\n");
mexPrintf("\t\t'wm' amount of memory (in megabytes) that the warp API is allowed to use for caching\n");
mexPrintf("\t\t'nodata' Set nodata values for output bands.\n");
mexPrintf("\t\t'ResampleAlg' To set up the algorithm used during warp operation. Options are: \n");
mexPrintf("\t\t\t'nearest' Use nearest neighbour resampling (default, fastest algorithm, worst interpolation quality).\n");
mexPrintf("\t\t\t'bilinear' Use bilinear resampling.\n");
mexPrintf("\t\t\t'cubic' Use cubic resampling.\n");
mexPrintf("\t\t\t'spline' Use cubic spline resampling.\n\n");
if (!runed_once) /* Do next call only at first time this MEX is loaded */
GDALAllRegister();
mexPrintf( "The following format drivers are configured and support Create() method:\n" );
for( i = 0; i < GDALGetDriverCount(); i++ ) {
hDriver = GDALGetDriver(i);
if( GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL ) != NULL)
mexPrintf("%s: %s\n", GDALGetDriverShortName(hDriver),
GDALGetDriverLongName(hDriver));
}
return;
}
n_dims = mxGetNumberOfDimensions(prhs[0]);
dim_array=mxGetDimensions(prhs[0]);
ny = dim_array[0];
nx = dim_array[1];
nBands = dim_array[2];
if (n_dims == 2) /* Otherwise it would stay undefined */
nBands = 1;
/* Find out in which data type was given the input array */
if (mxIsUint8(prhs[0])) {
typeCLASS = GDT_Byte; nBytes = 1;
outByte = (unsigned char *)mxMalloc (nx*ny * sizeof(unsigned char));
}
else if (mxIsUint16(prhs[0])) {
typeCLASS = GDT_UInt16; nBytes = 2;
outUI16 = (unsigned short int *)mxMalloc (nx*ny * sizeof(short int));
}
else if (mxIsInt16(prhs[0])) {
typeCLASS = GDT_Int16; nBytes = 2;
outI16 = (short int *)mxMalloc (nx*ny * sizeof(short int));
}
else if (mxIsInt32(prhs[0])) {
typeCLASS = GDT_Int32; nBytes = 4;
outI32 = (int *)mxMalloc (nx*ny * sizeof(int));
}
else if (mxIsUint32(prhs[0])) {
typeCLASS = GDT_UInt32; nBytes = 4;
outUI32 = (unsigned int *)mxMalloc (nx*ny * sizeof(int));
}
else if (mxIsSingle(prhs[0])) {
typeCLASS = GDT_Float32; nBytes = 4;
outF32 = (float *)mxMalloc (nx*ny * sizeof(float));
}
else if (mxIsDouble(prhs[0])) {
typeCLASS = GDT_Float64; nBytes = 8;
outF64 = (double *)mxMalloc (nx*ny * sizeof(double));
}
else
mexErrMsgTxt("GDALWARP Unknown input data class!");
in_data = (void *)mxGetData(prhs[0]);
if (!runed_once) /* Do next call only at first time this MEX is loaded */
GDALAllRegister();
hDriver = GDALGetDriverByName( "MEM" );
hSrcDS = GDALCreate( hDriver, "mem", nx, ny, nBands, (GDALDataType)typeCLASS, NULL );
if (hSrcDS == NULL) {
mexPrintf ("GDALOpen failed - %d\n%s\n", CPLGetLastErrorNo(), CPLGetLastErrorMsg());
return;
}
GDALSetGeoTransform( hSrcDS, adfGeoTransform );
/* ---------- Set the Source projection ---------------------------- */
/* If it was not provided assume it is Geog WGS84 */
if (pszSrcSRS == NULL && pszSrcWKT == NULL)
oSrcSRS.SetWellKnownGeogCS( "WGS84" );
else if (pszSrcWKT != NULL)
oSrcSRS.importFromWkt( &pszSrcWKT );
else {
if( oSrcSRS.SetFromUserInput( pszSrcSRS ) != OGRERR_NONE )
mexErrMsgTxt("GDAL_WARP_MEX: Translating source SRS failed.");
}
if (pszSrcWKT == NULL)
oSrcSRS.exportToWkt( &pszSrcWKT );
GDALSetProjection( hSrcDS, pszSrcWKT );
//pszSrcWKT = (char *)GDALGetProjectionRef( hSrcDS );
CPLAssert( pszSrcWKT != NULL && strlen(pszSrcWKT) > 0 );
/* ------------------------------------------------------------------ */
/* -------------- Copy input data into the hSrcDS dataset ----------- */
for (i = 1; i <= nBands; i++) {
hBand = GDALGetRasterBand( hSrcDS, i );
nXYSize = (i-1)*nx*ny;
switch( typeCLASS ) {
case GDT_Byte:
tmpByte = (unsigned char *)in_data;
for (m = ny-1, c = 0; m >= 0; m--) for (n = 0; n < nx; n++)
outByte[c++] = tmpByte[m + n*ny + nXYSize];
GDALRasterIO( hBand, GF_Write, 0, 0, nx, ny,outByte, nx, ny, (GDALDataType)typeCLASS, 0, 0 );
break;
case GDT_UInt16:
tmpUI16 = (unsigned short int *)in_data;
for (m = ny-1, c = 0; m >= 0; m--) for (n = 0; n < nx; n++)
outUI16[c++] = tmpUI16[m + n*ny + nXYSize];
GDALRasterIO( hBand, GF_Write, 0, 0, nx, ny,outUI16, nx, ny, (GDALDataType)typeCLASS, 0, 0 );
break;
case GDT_Int16:
tmpI16 = (short int *)in_data;
for (m = ny-1, c = 0; m >= 0; m--) for (n = 0; n < nx; n++)
outI16[c++] = tmpI16[m + n*ny + nXYSize];
GDALRasterIO( hBand, GF_Write, 0, 0, nx, ny,outI16, nx, ny, (GDALDataType)typeCLASS, 0, 0 );
break;
case GDT_UInt32:
tmpUI32 = (unsigned int *)in_data;
for (m = ny-1, c = 0; m >= 0; m--) for (n = 0; n < nx; n++)
outUI32[c++] = tmpUI32[m + n*ny + nXYSize];
GDALRasterIO( hBand, GF_Write, 0, 0, nx, ny,outUI32, nx, ny, (GDALDataType)typeCLASS, 0, 0 );
break;
case GDT_Int32:
tmpI32 = (int *)in_data;
for (m = ny-1, c = 0; m >= 0; m--) for (n = 0; n < nx; n++)
outI32[c++] = tmpI32[m + n*ny + nXYSize];
GDALRasterIO( hBand, GF_Write, 0, 0, nx, ny,outI32, nx, ny, (GDALDataType)typeCLASS, 0, 0 );
break;
case GDT_Float32:
tmpF32 = (float *)in_data;
for (m = ny-1, c = 0; m >= 0; m--) for (n = 0; n < nx; n++)
outF32[c++] = tmpF32[m + n*ny + nXYSize];
GDALRasterIO( hBand, GF_Write, 0, 0, nx, ny,outF32, nx, ny, (GDALDataType)typeCLASS, 0, 0 );
break;
case GDT_Float64:
tmpF64 = (double *)in_data;
for (m = ny-1, c = 0; m >= 0; m--) for (n = 0; n < nx; n++)
outF64[c++] = tmpF64[m + n*ny + nXYSize];
GDALRasterIO( hBand, GF_Write, 0, 0, nx, ny,outF64, nx, ny, (GDALDataType)typeCLASS, 0, 0 );
break;
}
}
/* ---------- Set up the Target coordinate system ------------------- */
/* If it was not provided assume it is Geog WGS84 */
CPLErrorReset();
if (pszDstSRS == NULL && pszDstWKT == NULL)
oDstSRS.SetWellKnownGeogCS( "WGS84" );
else if (pszDstWKT != NULL)
oDstSRS.importFromWkt( &pszDstWKT );
else {
if( oDstSRS.SetFromUserInput( pszDstSRS ) != OGRERR_NONE )
mexErrMsgTxt("GDAL_WARP_MEX: Translating target SRS failed.");
}
if (pszDstWKT == NULL)
oDstSRS.exportToWkt( &pszDstWKT );
/* ------------------------------------------------------------------ */
if ( nGCPCount != 0 ) {
if (GDALSetGCPs(hSrcDS, nGCPCount, pasGCPs, "") != CE_None)
mexPrintf("GDALWARP WARNING: writing GCPs failed.\n");
}
/* Create a transformer that maps from source pixel/line coordinates
to destination georeferenced coordinates (not destination pixel line)
We do that by omitting the destination dataset handle (setting it to NULL). */
void *hTransformArg;
hTransformArg = GDALCreateGenImgProjTransformer(hSrcDS, pszSrcWKT, NULL, pszDstWKT,
nGCPCount == 0 ? FALSE : TRUE, 0, nOrder);
if( hTransformArg == NULL )
mexErrMsgTxt("GDALTRANSFORM: Generating transformer failed.");
GDALTransformerInfo *psInfo = (GDALTransformerInfo*)hTransformArg;
/* -------------------------------------------------------------------------- */
/* Get approximate output georeferenced bounds and resolution for file
/* -------------------------------------------------------------------------- */
if (GDALSuggestedWarpOutput2(hSrcDS, GDALGenImgProjTransform, hTransformArg,
adfDstGeoTransform, &nPixels, &nLines, adfExtent,
0) != CE_None ) {
GDALClose(hSrcDS);
mexErrMsgTxt("GDALWARP: GDALSuggestedWarpOutput2 failed.");
}
if (CPLGetConfigOption( "CHECK_WITH_INVERT_PROJ", NULL ) == NULL) {
double MinX = adfExtent[0];
double MaxX = adfExtent[2];
double MaxY = adfExtent[3];
double MinY = adfExtent[1];
int bSuccess = TRUE;
/* Check that the the edges of the target image are in the validity area */
/* of the target projection */
#define N_STEPS 20
for (i = 0; i <= N_STEPS && bSuccess; i++) {
for (j = 0; j <= N_STEPS && bSuccess; j++) {
double dfRatioI = i * 1.0 / N_STEPS;
double dfRatioJ = j * 1.0 / N_STEPS;
double expected_x = (1 - dfRatioI) * MinX + dfRatioI * MaxX;
double expected_y = (1 - dfRatioJ) * MinY + dfRatioJ * MaxY;
double x = expected_x;
double y = expected_y;
double z = 0;
/* Target SRS coordinates to source image pixel coordinates */
if (!psInfo->pfnTransform(hTransformArg, TRUE, 1, &x, &y, &z, &bSuccess) || !bSuccess)
bSuccess = FALSE;
/* Source image pixel coordinates to target SRS coordinates */
if (!psInfo->pfnTransform(hTransformArg, FALSE, 1, &x, &y, &z, &bSuccess) || !bSuccess)
bSuccess = FALSE;
if (fabs(x - expected_x) > (MaxX - MinX) / nPixels ||
fabs(y - expected_y) > (MaxY - MinY) / nLines)
bSuccess = FALSE;
}
}
/* If not, retry with CHECK_WITH_INVERT_PROJ=TRUE that forces ogrct.cpp */
/* to check the consistency of each requested projection result with the */
/* invert projection */
if (!bSuccess) {
CPLSetConfigOption( "CHECK_WITH_INVERT_PROJ", "TRUE" );
CPLDebug("WARP", "Recompute out extent with CHECK_WITH_INVERT_PROJ=TRUE");
if (GDALSuggestedWarpOutput2(hSrcDS, GDALGenImgProjTransform, hTransformArg,
adfDstGeoTransform, &nPixels, &nLines, adfExtent,
0) != CE_None ) {
GDALClose(hSrcDS);
mexErrMsgTxt("GDALWARO: GDALSuggestedWarpOutput2 failed.");
}
}
}
/* -------------------------------------------------------------------- */
/* Expand the working bounds to include this region, ensure the */
/* working resolution is no more than this resolution. */
/* -------------------------------------------------------------------- */
if( dfMaxX == 0.0 && dfMinX == 0.0 ) {
dfMinX = adfExtent[0];
dfMaxX = adfExtent[2];
dfMaxY = adfExtent[3];
dfMinY = adfExtent[1];
dfResX = adfDstGeoTransform[1];
dfResY = ABS(adfDstGeoTransform[5]);
}
else {
dfMinX = MIN(dfMinX,adfExtent[0]);
dfMaxX = MAX(dfMaxX,adfExtent[2]);
dfMaxY = MAX(dfMaxY,adfExtent[3]);
dfMinY = MIN(dfMinY,adfExtent[1]);
dfResX = MIN(dfResX,adfDstGeoTransform[1]);
dfResY = MIN(dfResY,ABS(adfDstGeoTransform[5]));
}
GDALDestroyGenImgProjTransformer( hTransformArg );
/* -------------------------------------------------------------------- */
/* Turn the suggested region into a geotransform and suggested */
/* number of pixels and lines. */
/* -------------------------------------------------------------------- */
adfDstGeoTransform[0] = dfMinX;
adfDstGeoTransform[1] = dfResX;
adfDstGeoTransform[2] = 0.0;
adfDstGeoTransform[3] = dfMaxY;
adfDstGeoTransform[4] = 0.0;
adfDstGeoTransform[5] = -1 * dfResY;
nPixels = (int) ((dfMaxX - dfMinX) / dfResX + 0.5);
nLines = (int) ((dfMaxY - dfMinY) / dfResY + 0.5);
/* -------------------------------------------------------------------- */
/* Did the user override some parameters? */
/* -------------------------------------------------------------------- */
if( dfXRes != 0.0 && dfYRes != 0.0 ) {
dfMinX = adfDstGeoTransform[0];
dfMaxX = adfDstGeoTransform[0] + adfDstGeoTransform[1] * nPixels;
dfMaxY = adfDstGeoTransform[3];
dfMinY = adfDstGeoTransform[3] + adfDstGeoTransform[5] * nLines;
nPixels = (int) ((dfMaxX - dfMinX + (dfXRes/2.0)) / dfXRes);
nLines = (int) ((dfMaxY - dfMinY + (dfYRes/2.0)) / dfYRes);
adfDstGeoTransform[0] = dfMinX;
adfDstGeoTransform[3] = dfMaxY;
adfDstGeoTransform[1] = dfXRes;
adfDstGeoTransform[5] = -dfYRes;
}
else if( nForceWidth != 0 && nForceHeight != 0 ) {
dfXRes = (dfMaxX - dfMinX) / nForceWidth;
dfYRes = (dfMaxY - dfMinY) / nForceHeight;
adfDstGeoTransform[0] = dfMinX;
adfDstGeoTransform[3] = dfMaxY;
adfDstGeoTransform[1] = dfXRes;
adfDstGeoTransform[5] = -dfYRes;
nPixels = nForceWidth;
nLines = nForceHeight;
}
else if( nForceWidth != 0) {
dfXRes = (dfMaxX - dfMinX) / nForceWidth;
dfYRes = dfXRes;
adfDstGeoTransform[0] = dfMinX;
adfDstGeoTransform[3] = dfMaxY;
adfDstGeoTransform[1] = dfXRes;
adfDstGeoTransform[5] = -dfYRes;
nPixels = nForceWidth;
nLines = (int) ((dfMaxY - dfMinY + (dfYRes/2.0)) / dfYRes);
}
else if( nForceHeight != 0) {
dfYRes = (dfMaxY - dfMinY) / nForceHeight;
dfXRes = dfYRes;
adfDstGeoTransform[0] = dfMinX;
adfDstGeoTransform[3] = dfMaxY;
adfDstGeoTransform[1] = dfXRes;
adfDstGeoTransform[5] = -dfYRes;
nPixels = (int) ((dfMaxX - dfMinX + (dfXRes/2.0)) / dfXRes);
nLines = nForceHeight;
}
/* --------------------- Create the output --------------------------- */
hDstDS = GDALCreate( hDriver, "mem", nPixels, nLines,
GDALGetRasterCount(hSrcDS), (GDALDataType)typeCLASS, NULL );
CPLAssert( hDstDS != NULL );
/* -------------- Write out the projection definition ---------------- */
GDALSetProjection( hDstDS, pszDstWKT );
GDALSetGeoTransform( hDstDS, adfDstGeoTransform );
/* --------------------- Setup warp options -------------------------- */
GDALWarpOptions *psWO = GDALCreateWarpOptions();
psWO->hSrcDS = hSrcDS;
psWO->hDstDS = hDstDS;
psWO->nBandCount = nBands;
psWO->panSrcBands = (int *) CPLMalloc(psWO->nBandCount * sizeof(int) );
psWO->panDstBands = (int *) CPLMalloc(psWO->nBandCount * sizeof(int) );
for( i = 0; i < nBands; i++ ) {
psWO->panSrcBands[i] = i+1;
psWO->panDstBands[i] = i+1;
}
if( dfWarpMemoryLimit != 0.0 )
psWO->dfWarpMemoryLimit = dfWarpMemoryLimit;
/* --------------------- Setup the Resampling Algo ------------------- */
psWO->eResampleAlg = interpMethod;
/* --------------------- Setup NODATA options ------------------------ */
papszWarpOptions = CSLSetNameValue(papszWarpOptions, "INIT_DEST", "NO_DATA" );
if ( pdfDstNodata == NULL && (typeCLASS == GDT_Float32 || typeCLASS == GDT_Float64) ) {
pdfDstNodata = (double *) mxCalloc((size_t)1, sizeof(double));
*pdfDstNodata = mxGetNaN();
}
else if (pdfDstNodata != NULL) {
#define CLAMP(val,type,minval,maxval) \
do { if (val < minval) { val = minval; } \
else if (val > maxval) { val = maxval; } \
else if (val != (type)val) { val = (type)(val + 0.5); } } \
while(0)
switch( typeCLASS ) {
case GDT_Byte:
CLAMP(pdfDstNodata[0], GByte, 0.0, 255.0);
break;
case GDT_UInt16:
CLAMP(pdfDstNodata[0], GInt16, -32768.0, 32767.0);
break;
case GDT_Int16:
CLAMP(pdfDstNodata[0], GUInt16, 0.0, 65535.0);
break;
case GDT_UInt32:
CLAMP(pdfDstNodata[0], GInt32, -2147483648.0, 2147483647.0);
break;
case GDT_Int32:
CLAMP(pdfDstNodata[0], GUInt32, 0.0, 4294967295.0);
break;
default:
break;
}
}
psWO->papszWarpOptions = CSLDuplicate(papszWarpOptions);
if (pdfDstNodata != NULL) {
psWO->padfDstNoDataReal = (double *) CPLMalloc(psWO->nBandCount*sizeof(double));
psWO->padfDstNoDataImag = (double *) CPLMalloc(psWO->nBandCount*sizeof(double));
for (i = 0; i < nBands; i++) {
psWO->padfDstNoDataReal[i] = pdfDstNodata[0];
psWO->padfDstNoDataImag[i] = 0.0;
GDALSetRasterNoDataValue( GDALGetRasterBand(hDstDS, i+1), pdfDstNodata[0]);
}
}
/* ------------ Establish reprojection transformer ------------------- */
psWO->pTransformerArg = GDALCreateGenImgProjTransformer( hSrcDS, GDALGetProjectionRef(hSrcDS),
hDstDS, GDALGetProjectionRef(hDstDS),
nGCPCount == 0 ? FALSE : TRUE, 0.0, nOrder );
psWO->pfnTransformer = GDALGenImgProjTransform;
/* ----------- Initialize and execute the warp operation ------------- */
GDALWarpOperation oOperation;
oOperation.Initialize( psWO );
eErr = oOperation.ChunkAndWarpImage( 0, 0, GDALGetRasterXSize( hDstDS ),
GDALGetRasterYSize( hDstDS ) );
CPLAssert( eErr == CE_None );
GDALDestroyGenImgProjTransformer( psWO->pTransformerArg );
GDALDestroyWarpOptions( psWO );
GDALClose( hSrcDS );
/* ------------ Free memory used to fill the hSrcDS dataset ---------- */
switch( typeCLASS ) {
case GDT_Byte: mxFree((void *)outByte); break;
case GDT_UInt16: mxFree((void *)outUI16); break;
case GDT_Int16: mxFree((void *)outI16); break;
case GDT_UInt32: mxFree((void *)outUI32); break;
case GDT_Int32: mxFree((void *)outI32); break;
case GDT_Float32: mxFree((void *)outF32); break;
case GDT_Float64: mxFree((void *)outF64); break;
}
int out_dims[3];
out_dims[0] = nLines;
out_dims[1] = nPixels;
out_dims[2] = nBands;
plhs[0] = mxCreateNumericArray (n_dims,out_dims,mxGetClassID(prhs[0]), mxREAL);
tmp = (char *)mxCalloc(nPixels * nLines, nBytes);
/* ------ Allocate memory to be used in filling the hDstDS dataset ---- */
switch( typeCLASS ) {
case GDT_Byte:
outByte = (unsigned char *)mxGetData(plhs[0]); break;
case GDT_UInt16:
outUI16 = (unsigned short int *)mxGetData(plhs[0]); break;
case GDT_Int16:
outI16 = (short int *)mxGetData(plhs[0]); break;
case GDT_UInt32:
outUI32 = (unsigned int *)mxGetData(plhs[0]); break;
case GDT_Int32:
outI32 = (int *)mxGetData(plhs[0]); break;
case GDT_Float32:
outF32 = (float *)mxGetData(plhs[0]); break;
case GDT_Float64:
outF64 = (double *)mxGetData(plhs[0]); break;
}
/* ----------- Copy the output hSrcDS dataset data into plhs ---------- */
for (i = 1; i <= nBands; i++) {
hBand = GDALGetRasterBand( hDstDS, i );
GDALRasterIO( hBand, GF_Read, 0, 0, nPixels, nLines, tmp, nPixels, nLines,
(GDALDataType)typeCLASS, 0, 0 );
nXYSize = (i-1) * nPixels * nLines;
switch( typeCLASS ) {
case GDT_Byte:
for (m = nLines-1, c = 0; m >= 0; m--) for (n = 0; n < nPixels; n++)
outByte[m + n*nLines + nXYSize] = tmp[c++];
break;
case GDT_UInt16:
tmpUI16 = (GUInt16 *) tmp;
for (m = nLines-1, c = 0; m >= 0; m--) for (n = 0; n < nPixels; n++)
outUI16[m + n*nLines + nXYSize] = tmpUI16[c++];
break;
case GDT_Int16:
tmpI16 = (GInt16 *) tmp;
for (m = nLines-1, c = 0; m >= 0; m--) for (n = 0; n < nPixels; n++)
outI16[m + n*nLines + nXYSize] = tmpI16[c++];
break;
case GDT_UInt32:
tmpUI32 = (GUInt32 *) tmp;
for (m = nLines-1, c = 0; m >= 0; m--) for (n = 0; n < nPixels; n++)
outUI32[m + n*nLines + nXYSize] = tmpUI32[c++];
break;
case GDT_Int32:
tmpI32 = (GInt32 *) tmp;
for (m = nLines-1, c = 0; m >= 0; m--) for (n = 0; n < nPixels; n++)
outI32[m + n*nLines + nXYSize] = tmpI32[c++];
break;
case GDT_Float32:
tmpF32 = (float *) tmp;
for (m = nLines-1, c = 0; m >= 0; m--) for (n = 0; n < nPixels; n++)
outF32[m + n*nLines + nXYSize] = tmpF32[c++];
break;
case GDT_Float64:
tmpF64 = (double *) tmp;
for (m = nLines-1, c = 0; m >= 0; m--) for (n = 0; n < nPixels; n++)
outF64[m + n*nLines + nXYSize] = tmpF64[c++];
break;
}
}
mxFree(tmp);
if (nGCPCount) {
GDALDeinitGCPs( nGCPCount, pasGCPs ); /* makes this mex crash in the next call - Is it still true??? */
mxFree((void *) pasGCPs );
}
if (nlhs == 2)
plhs[1] = populate_metadata_struct (hDstDS, 1);
runed_once = TRUE; /* Signals that next call won't need to call GDALAllRegister() again */
/*GDALDestroyDriverManager();
OGRFree(pszDstWKT);*/
GDALClose( hDstDS );
CSLDestroy( papszWarpOptions );
if (pszDstWKT && strlen(pszDstWKT) > 1 ) OGRFree(pszDstWKT);
if (pszSrcWKT && strlen(pszSrcWKT) > 1 ) OGRFree(pszSrcWKT);
}
int main( int argc, char ** argv )
{
GDALDatasetH hDataset, hOutDS;
int i;
const char *pszSource=NULL, *pszDest=NULL, *pszFormat = "GTiff";
int bFormatExplicitlySet = FALSE;
GDALDriverH hDriver;
GDALDataType eOutputType = GDT_Unknown;
char **papszCreateOptions = NULL;
GDALProgressFunc pfnProgress = GDALTermProgress;
int nLUTBins = 256;
const char *pszMethod = "minmax";
// double dfStdDevMult = 0.0;
double *padfScaleMin = NULL;
double *padfScaleMax = NULL;
int **papanLUTs = NULL;
int iBand;
const char *pszConfigFile = NULL;
int bQuiet = FALSE;
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(argv[0]))
exit(1);
/* -------------------------------------------------------------------- */
/* Register standard GDAL drivers, and process generic GDAL */
/* command options. */
/* -------------------------------------------------------------------- */
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Handle command line arguments. */
/* -------------------------------------------------------------------- */
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(argv[i],"-of") && i < argc-1 )
{
pszFormat = argv[++i];
bFormatExplicitlySet = TRUE;
}
else if( EQUAL(argv[i],"-ot") && i < argc-1 )
{
int iType;
for( iType = 1; iType < GDT_TypeCount; iType++ )
{
if( GDALGetDataTypeName((GDALDataType)iType) != NULL
&& EQUAL(GDALGetDataTypeName((GDALDataType)iType),
argv[i+1]) )
{
eOutputType = (GDALDataType) iType;
}
}
if( eOutputType == GDT_Unknown )
{
printf( "Unknown output pixel type: %s\n", argv[i+1] );
Usage();
}
i++;
}
else if( EQUALN(argv[i],"-s_nodata",9) )
{
// TODO
i += 1;
}
else if( EQUAL(argv[i],"-co") && i < argc-1 )
{
papszCreateOptions = CSLAddString( papszCreateOptions, argv[++i] );
}
else if( EQUALN(argv[i],"-src_scale",10) && i < argc-2)
{
// TODO
i += 2;
}
else if( EQUALN(argv[i],"-dst_scale",10) && i < argc-2 )
{
// TODO
i += 2;
}
else if( EQUAL(argv[i],"-config") && i < argc-1 )
{
pszConfigFile = argv[++i];
}
else if( EQUAL(argv[i],"-equalize") )
{
pszMethod = "equalize";
}
else if( EQUAL(argv[i],"-quiet") )
{
pfnProgress = GDALDummyProgress;
bQuiet = TRUE;
}
else if( argv[i][0] == '-' )
{
printf( "Option %s incomplete, or not recognised.\n\n",
argv[i] );
Usage();
}
else if( pszSource == NULL )
{
pszSource = argv[i];
}
else if( pszDest == NULL )
{
pszDest = argv[i];
}
else
{
printf( "Too many command options.\n\n" );
Usage();
}
}
if( pszSource == NULL )
{
Usage();
}
/* -------------------------------------------------------------------- */
/* Attempt to open source file. */
/* -------------------------------------------------------------------- */
hDataset = GDALOpenShared( pszSource, GA_ReadOnly );
if( hDataset == NULL )
{
fprintf( stderr,
"GDALOpen failed - %d\n%s\n",
CPLGetLastErrorNo(), CPLGetLastErrorMsg() );
GDALDestroyDriverManager();
exit( 1 );
}
int nBandCount = GDALGetRasterCount(hDataset);
/* -------------------------------------------------------------------- */
/* Find the output driver. */
/* -------------------------------------------------------------------- */
hDriver = GDALGetDriverByName( pszFormat );
if( hDriver == NULL )
{
int iDr;
printf( "Output driver `%s' not recognised.\n", pszFormat );
printf( "The following format drivers are configured and support output:\n" );
for( iDr = 0; iDr < GDALGetDriverCount(); iDr++ )
{
GDALDriverH hDriver = GDALGetDriver(iDr);
if( GDALGetMetadataItem( hDriver, GDAL_DCAP_RASTER, NULL) != NULL &&
(GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL ) != NULL
|| GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATECOPY, NULL ) != NULL) )
{
printf( " %s: %s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ) );
}
}
printf( "\n" );
Usage();
}
if (!bQuiet && pszDest != NULL && !bFormatExplicitlySet)
CheckExtensionConsistency(pszDest, pszFormat);
/* -------------------------------------------------------------------- */
/* If histogram equalization is requested, do it now. */
/* -------------------------------------------------------------------- */
if( EQUAL(pszMethod,"equalize") )
{
ComputeEqualizationLUTs( hDataset, nLUTBins,
&padfScaleMin, &padfScaleMax,
&papanLUTs, pfnProgress );
}
/* -------------------------------------------------------------------- */
/* If we have a config file, assume it is for input and read */
/* it. */
/* -------------------------------------------------------------------- */
else if( pszConfigFile != NULL )
{
char **papszLines = CSLLoad( pszConfigFile );
if( CSLCount(papszLines) == 0 )
exit( 1 );
if( CSLCount(papszLines) != nBandCount )
{
fprintf( stderr, "Did not get %d lines in config file as expected.\n", nBandCount );
exit( 1 );
}
padfScaleMin = (double *) CPLCalloc(nBandCount,sizeof(double));
padfScaleMax = (double *) CPLCalloc(nBandCount,sizeof(double));
for( iBand = 0; iBand < nBandCount; iBand++ )
{
int iLUT;
char **papszTokens = CSLTokenizeString( papszLines[iBand] );
if( CSLCount(papszTokens) < 3
|| atoi(papszTokens[0]) != iBand+1 )
{
fprintf( stderr, "Line %d seems to be corrupt.\n", iBand+1 );
exit( 1 );
}
// Process scale min/max
padfScaleMin[iBand] = CPLAtof(papszTokens[1]);
padfScaleMax[iBand] = CPLAtof(papszTokens[2]);
if( CSLCount(papszTokens) == 3 )
continue;
// process lut
if( iBand == 0 )
{
nLUTBins = CSLCount(papszTokens) - 3;
papanLUTs = (int **) CPLCalloc(sizeof(int*),nBandCount);
}
papanLUTs[iBand] = (int *) CPLCalloc(nLUTBins,sizeof(int));
for( iLUT = 0; iLUT < nLUTBins; iLUT++ )
papanLUTs[iBand][iLUT] = atoi(papszTokens[iLUT+3]);
CSLDestroy( papszTokens );
}
}
/* -------------------------------------------------------------------- */
/* If there is no destination, just report the scaling values */
/* and luts. */
/* -------------------------------------------------------------------- */
if( pszDest == NULL )
{
FILE *fpConfig = stdout;
if( pszConfigFile )
fpConfig = fopen( pszConfigFile, "w" );
for( iBand = 0; iBand < nBandCount; iBand++ )
{
fprintf( fpConfig, "%d:Band ", iBand+1 );
if( padfScaleMin != NULL )
fprintf( fpConfig, "%g:ScaleMin %g:ScaleMax ",
padfScaleMin[iBand], padfScaleMax[iBand] );
if( papanLUTs )
{
int iLUT;
for( iLUT = 0; iLUT < nLUTBins; iLUT++ )
fprintf( fpConfig, "%d ", papanLUTs[iBand][iLUT] );
}
fprintf( fpConfig, "\n" );
}
if( pszConfigFile )
fclose( fpConfig );
exit( 0 );
}
if (padfScaleMin == NULL || padfScaleMax == NULL)
{
fprintf( stderr, "-equalize or -config filename command line options must be specified.\n");
exit(1);
}
/* ==================================================================== */
/* Create a virtual dataset. */
/* ==================================================================== */
VRTDataset *poVDS;
EnhanceCBInfo *pasEInfo = (EnhanceCBInfo *)
CPLCalloc(nBandCount, sizeof(EnhanceCBInfo));
/* -------------------------------------------------------------------- */
/* Make a virtual clone. */
/* -------------------------------------------------------------------- */
poVDS = new VRTDataset( GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset) );
if( GDALGetGCPCount(hDataset) == 0 )
{
const char *pszProjection;
double adfGeoTransform[6];
pszProjection = GDALGetProjectionRef( hDataset );
if( pszProjection != NULL && strlen(pszProjection) > 0 )
poVDS->SetProjection( pszProjection );
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
poVDS->SetGeoTransform( adfGeoTransform );
}
else
{
poVDS->SetGCPs( GDALGetGCPCount(hDataset),
GDALGetGCPs(hDataset),
GDALGetGCPProjection( hDataset ) );
}
poVDS->SetMetadata( ((GDALDataset*)hDataset)->GetMetadata() );
for( iBand = 0; iBand < nBandCount; iBand++ )
{
VRTSourcedRasterBand *poVRTBand;
GDALRasterBand *poSrcBand;
GDALDataType eBandType;
poSrcBand = ((GDALDataset *) hDataset)->GetRasterBand(iBand+1);
/* -------------------------------------------------------------------- */
/* Select output data type to match source. */
/* -------------------------------------------------------------------- */
if( eOutputType == GDT_Unknown )
eBandType = GDT_Byte;
else
eBandType = eOutputType;
/* -------------------------------------------------------------------- */
/* Create this band. */
/* -------------------------------------------------------------------- */
poVDS->AddBand( eBandType, NULL );
poVRTBand = (VRTSourcedRasterBand *) poVDS->GetRasterBand( iBand+1 );
/* -------------------------------------------------------------------- */
/* Create a function based source with info on how to apply the */
/* enhancement. */
/* -------------------------------------------------------------------- */
pasEInfo[iBand].poSrcBand = poSrcBand;
pasEInfo[iBand].eWrkType = eBandType;
pasEInfo[iBand].dfScaleMin = padfScaleMin[iBand];
pasEInfo[iBand].dfScaleMax = padfScaleMax[iBand];
pasEInfo[iBand].nLUTBins = nLUTBins;
if( papanLUTs )
pasEInfo[iBand].panLUT = papanLUTs[iBand];
poVRTBand->AddFuncSource( EnhancerCallback, pasEInfo + iBand );
/* -------------------------------------------------------------------- */
/* copy over some other information of interest. */
/* -------------------------------------------------------------------- */
poVRTBand->CopyCommonInfoFrom( poSrcBand );
}
/* -------------------------------------------------------------------- */
/* Write to the output file using CopyCreate(). */
/* -------------------------------------------------------------------- */
hOutDS = GDALCreateCopy( hDriver, pszDest, (GDALDatasetH) poVDS,
FALSE, papszCreateOptions,
pfnProgress, NULL );
if( hOutDS != NULL )
GDALClose( hOutDS );
GDALClose( (GDALDatasetH) poVDS );
GDALClose( hDataset );
/* -------------------------------------------------------------------- */
/* Cleanup and exit. */
/* -------------------------------------------------------------------- */
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CSLDestroy( argv );
CSLDestroy( papszCreateOptions );
exit( 0 );
}
/*
Function: Init
Input: TBD
Shader base: rothermel
Purpose: Initializes the sim.
*/
void fireSim::init(){
// read from files:
int cell = 0;
float* slopeTexTmp = NULL;
GDALAllRegister();
fuelTexture = GISToFloatArray<int>(fuelTextureFile, simDimX, simDimY);
slopeTexTmp = GISToFloatArray<float>(slopeAspectElevationTextureFile, simDimX*3, simDimY*3);
for(int i = 0; i < simDimX; i++){
for(int j = 0; j < simDimY; j++, cell++){
timeOfArrival[i][j] = 20.;
rothData[i][j].x = rothData[i][j].y = rothData[i][j].z = 0.;
// fuelTexture[i][j] = 0.;
originalTimeOfArrival[i][j] = 20.;
orthoSpreadRate[i][j].x = orthoSpreadRate[i][j].y = orthoSpreadRate[i][j].z = orthoSpreadRate[i][j].w = 1.;
diagSpreadRate[i][j].x = diagSpreadRate[i][j].y = diagSpreadRate[i][j].z = diagSpreadRate[i][j].w = 1.;
orthoMaxSpreadRate[i][j].x =orthoMaxSpreadRate[i][j].y = orthoMaxSpreadRate[i][j].z = orthoMaxSpreadRate[i][j].w = 100.;
diagMaxSpreadRate[i][j].x = diagMaxSpreadRate[i][j].y = diagMaxSpreadRate[i][j].z = diagMaxSpreadRate[i][j].w = 100.;
orthoBurnDistance[i][j].x = orthoBurnDistance[i][j].y = orthoBurnDistance[i][j].z = orthoBurnDistance[i][j].w = .2;
diagBurnDistance[i][j].x = diagBurnDistance[i][j].y = diagBurnDistance[i][j].z = diagBurnDistance[i][j].w = .2;
updateStamp[i][j] = 0.;
sourceDataTexture[i][j].x = sourceDataTexture[i][j].y = 0.;
crownThreshold[i][j] = 0.0;
crownActiveRate[i][j] = 100000.;
canopyHeight[i][j] = 0.;
spreadData[i][j] = 0.;
// Rothermel Data Members
windTexture[i][j].x = windTexture[i][j].y = 0.;
slopeAspectElevationTexture[cell].x = slopeTexTmp[3*cell];
slopeAspectElevationTexture[cell].y = slopeTexTmp[3*cell+1];
slopeAspectElevationTexture[cell].z = slopeTexTmp[3*cell+2];
ignTime[cell] = INF;
ignTimeNew[cell] = INF;
for(int k = 0; k < 8; k++){
burnDist[cell][k] = L_n[k];
}
}
}
spreadData[5][5] = 100;
int ignSpot = simDimX * simDimY / 2 + simDimY / 2;
ignTime[ignSpot] = 0;
ignTimeNew[ignSpot] = 0;
timeStep = 2.0;
int i = 0;
for (std::vector<sim::FuelModel>::iterator it = _models.begin();
it != _models.end(); it++, i++)
{
dead1hBuffer[i].x = it->effectiveHeatingNumber[sim::Dead1h];
dead1hBuffer[i].y = it->load[sim::Dead1h];
dead1hBuffer[i].z = it->areaWeightingFactor[sim::Dead1h];
dead1hBuffer[i].w = it->fuelMoisture[sim::Dead1h];
dead10hBuffer[i].x = it->effectiveHeatingNumber[sim::Dead10h];
dead10hBuffer[i].y = it->load[sim::Dead10h];
dead10hBuffer[i].z = it->areaWeightingFactor[sim::Dead10h];
dead10hBuffer[i].w = it->fuelMoisture[sim::Dead10h];
dead100hBuffer[i].x = it->effectiveHeatingNumber[sim::Dead100h];
dead100hBuffer[i].y = it->load[sim::Dead100h];
dead100hBuffer[i].z = it->areaWeightingFactor[sim::Dead100h];
dead100hBuffer[i].w = it->fuelMoisture[sim::Dead100h];
liveHBuffer[i].x = it->effectiveHeatingNumber[sim::LiveH];
liveHBuffer[i].y = it->load[sim::LiveH];
liveHBuffer[i].z = it->areaWeightingFactor[sim::LiveH];
liveHBuffer[i].w = it->fuelMoisture[sim::LiveH];
liveWBuffer[i].x = it->effectiveHeatingNumber[sim::LiveW];
liveWBuffer[i].y = it->load[sim::LiveW];
liveWBuffer[i].z = it->areaWeightingFactor[sim::LiveW];
liveWBuffer[i].w = it->fuelMoisture[sim::LiveW];
fineDeadExtinctionsDensityBuffer[i].x = it->fineDeadRatio;
fineDeadExtinctionsDensityBuffer[i].y = it->extinctionMoisture;
fineDeadExtinctionsDensityBuffer[i].z = it->liveExtinction;
fineDeadExtinctionsDensityBuffer[i].w = it->fuelDensity;
areasReactionFactorsBuffer[i].x = it->deadArea;
areasReactionFactorsBuffer[i].y = it->liveArea;
areasReactionFactorsBuffer[i].z = it->deadReactionFactor;
areasReactionFactorsBuffer[i].w = it->liveReactionFactor;
slopeWindFactorsBuffer[i].x = it->slopeK;
slopeWindFactorsBuffer[i].y = it->windK;
slopeWindFactorsBuffer[i].z = it->windB;
slopeWindFactorsBuffer[i].w = it->windE;
residenceFluxLiveSAVBuffer[i].x = it->residenceTime;
residenceFluxLiveSAVBuffer[i].y = it->propagatingFlux;
residenceFluxLiveSAVBuffer[i].z = it->SAV[sim::LiveH];
residenceFluxLiveSAVBuffer[i].w = it->SAV[sim::LiveW];
deadSAVBurnableBuffer[i].x = it->SAV[sim::Dead1h];
deadSAVBurnableBuffer[i].y = it->SAV[sim::Dead10h];
deadSAVBurnableBuffer[i].z = it->SAV[sim::Dead100h];
// deadSAVBurnableBuffer[i].w = it->burnable? 100.0f : 0.0f;
deadSAVBurnableBuffer[i].w = 100.0f;
fuelSAVAccelBuffer[i].x = it->fuelSAV;
fuelSAVAccelBuffer[i].y = it->accelerationConstant;
}
i = 0;
for (std::vector<sim::FuelMoisture>::iterator it = _moistures.begin();
it != _moistures.end(); it++, i++)
{
deadMoisturesTexture[i].x = it->dead1h;
deadMoisturesTexture[i].y = it->dead10h;
deadMoisturesTexture[i].z = it->dead100h;
liveMoisturesTexture[i].x = it->liveH;
liveMoisturesTexture[i].y = it->liveW;
}
}
int main(int argc, char* argv[])
{
int status = PV_SUCCESS;
PV::PV_Init * pv_init = new PV_Init(&argc, &argv);
pv_init -> initialize(argc, argv);
// Build the column from the params file
PV::ParamGroupHandler * customGroupHandler[1];
customGroupHandler[0] = new PASCALCustomGroupHandler();
PV::HyPerCol * hc = build(argc, argv, pv_init, customGroupHandler, 1);
assert(hc->getStartTime()==hc->simulationTime());
double startTime = hc->getStartTime();
double stopTime = hc->getStopTime();
double dt = hc->getDeltaTime();
double displayPeriod = stopTime - startTime;
const int rank = hc->columnId();
InterColComm * icComm = hc->icCommunicator();
// // These variables are only used by the root process, but must be defined here
// // since they need to persist from one if(rank==0) statement to the next.
// char * imageLayerName = NULL;
// char * resultLayerName = NULL;
// char * resultTextFile = NULL;
// char * octaveCommand = NULL;
// char * octaveLogFile = NULL;
// char * classNames = NULL;
// char * evalCategoryIndices = NULL;
// char * displayCategoryIndices = NULL;
// char * highlightThreshold = NULL;
// char * heatMapThreshold = NULL;
// char * heatMapMaximum = NULL;
// char * drawBoundingBoxes = NULL;
// char * boundingBoxThickness = NULL;
// char * dbscanEps = NULL;
// char * dbscanDensity = NULL;
// char * heatMapMontageDir = NULL;
// char * displayCommand = NULL;
int layerNx, layerNy, layerNf;
int imageNx, imageNy, imageNf;
int bufferNx, bufferNy, bufferNf;
size_t imageBufferSize;
uint8_t * imageBuffer;
int octavepid = 0; // pid of the child octave process.
PV::ImageFromMemoryBuffer * imageLayer = NULL;
for (int k=0; k<hc->numberOfLayers(); k++) {
PV::HyPerLayer * l = hc->getLayer(k);
PV::ImageFromMemoryBuffer * img_buffer_layer = dynamic_cast<PV::ImageFromMemoryBuffer *>(l);
if (img_buffer_layer) {
if (imageLayer!=NULL) {
if (hc->columnId()==0) {
fprintf(stderr, "%s error: More than one ImageFromMemoryBuffer (\"%s\" and \"%s\").\n",
argv[0], imageLayer->getName(), img_buffer_layer->getName());
}
MPI_Barrier(hc->icCommunicator()->communicator());
exit(EXIT_FAILURE);
}
else {
imageLayer = img_buffer_layer;
}
}
}
//
// BaseLayer * imageBaseLayer = hc->getLayerFromName(imageLayerName);
// if (imageBaseLayer==NULL)
// {
// if (rank==0) {
// fprintf(stderr, "%s error: no layer matches imageLayerName = \"%s\"\n", argv[0], imageLayerName);
// }
// status = PV_FAILURE;
// }
// ImageFromMemoryBuffer * imageLayer = dynamic_cast<ImageFromMemoryBuffer *>(imageBaseLayer);
// if (imageLayer==NULL)
// {
// if (rank==0) {
// fprintf(stderr, "%s error: imageLayerName = \"%s\" is not an ImageFromMemoryBuffer layer\n", argv[0], imageLayerName);
// }
// status = PV_FAILURE;
// }
//
// BaseLayer * resultBaseLayer = hc->getLayerFromName(resultLayerName);
// if (resultBaseLayer==NULL)
// {
// if (rank==0) {
// fprintf(stderr, "%s error: no layer matches resultLayerName = \"%s\"\n", argv[0], resultLayerName);
// }
// status = PV_FAILURE;
// }
// HyPerLayer * resultLayer = dynamic_cast<HyPerLayer *>(resultBaseLayer);
// if (resultLayer==NULL)
// {
// if (rank==0) {
// fprintf(stderr, "%s error: resultLayerName = \"%s\" is not a HyPerLayer\n", argv[0], resultLayerName);
// }
// status = PV_FAILURE;
// }
if (rank==0) {
if (status != PV_SUCCESS) { exit(EXIT_FAILURE); }
// // clobber octave logfile and result text file unless starting from a checkpoint
// if (hc->getCheckpointReadDir()==NULL) {
// FILE * octavefp = fopen(octaveLogFile, "w");
// fclose(octavefp);
// if (resultTextFile) {
// FILE * resultTextFP = fopen(resultTextFile, "w")
// fclose(resultTextFP);
// }
// }
layerNx = imageLayer->getLayerLoc()->nxGlobal;
layerNy = imageLayer->getLayerLoc()->nyGlobal;
layerNf = imageLayer->getLayerLoc()->nf;
imageNx = layerNx;
imageNy = layerNy;
imageNf = 3;
bufferNx = layerNx;
bufferNy = layerNy;
bufferNf = imageNf;
imageBufferSize = (size_t)bufferNx*(size_t)bufferNy*(size_t)bufferNf;
imageBuffer = NULL;
GDALAllRegister();
// struct stat heatMapMontageStat;
// status = stat(heatMapMontageDir, &heatMapMontageStat);
// if (status!=0 && errno==ENOENT) {
// status = mkdir(heatMapMontageDir, 0770);
// if (status!=0) {
// fprintf(stderr, "Error: Unable to make heat map montage directory \"%s\": %s\n", heatMapMontageDir, strerror(errno));
// exit(EXIT_FAILURE);
// }
// status = stat(heatMapMontageDir, &heatMapMontageStat);
// }
// if (status!=0) {
// fprintf(stderr, "Error: Unable to get status of heat map montage directory \"%s\": %s\n", heatMapMontageDir, strerror(errno));
// exit(EXIT_FAILURE);
// }
// if (!(heatMapMontageStat.st_mode & S_IFDIR)) {
// fprintf(stderr, "Error: Heat map montage \"%s\" is not a directory\n", heatMapMontageDir);
// exit(EXIT_FAILURE);
// }
}
// Main loop: get an image, load it into the image layer, do HyPerCol::run(), lather, rinse, repeat
char * imageFile = getImageFileName(icComm);
while(imageFile!=NULL && imageFile[0]!='\0')
{
startTime = hc->simulationTime();
stopTime = startTime + displayPeriod;
setImageLayerMemoryBuffer(hc->icCommunicator(), imageFile, imageLayer, &imageBuffer, &imageBufferSize);
hc->run(startTime, stopTime, dt);
// int numParams = 20;
// int params[numParams];
//
// char const * imagePvpFile = rank ? 0 : imageLayer->getOutputStatePath();
// char const * resultPvpFile = rank ? 0 : resultLayer->getOutputStatePath();
// PV_Stream * imagePvpStream = NULL;
// PV_Stream * resultPvpStream = NULL;
//
// if (rank==0) {
// imageLayer->flushOutputStateStream();
// imagePvpStream = PV_fopen(imagePvpFile, "r", false/*verifyWrites*/);
// }
// status = pvp_read_header(imagePvpStream, hc->icCommunicator(), params, &numParams);
// if (status!=PV_SUCCESS)
// {
// fprintf(stderr, "pvp_read_header for imageLayer \"%s\" outputfile \"%s\" failed.\n", imageLayer->getName(), imagePvpFile);
// exit(EXIT_FAILURE);
// }
// if (rank==0) { PV_fclose(imagePvpStream); }
// assert(numParams==20);
// int imageFrameNumber = params[INDEX_NBANDS];
//
// if (rank==0) {
// resultLayer->flushOutputStateStream();
// resultPvpStream = PV_fopen(resultPvpFile, "r", false/*verifyWrites*/);
// }
// status = pvp_read_header(resultPvpStream, hc->icCommunicator(), params, &numParams);
// if (status!=PV_SUCCESS)
// {
// fprintf(stderr, "pvp_read_header for resultLayer \"%s\" outputfile \"%s\" failed.\n", resultLayer->getName(), resultPvpFile);
// exit(EXIT_FAILURE);
// }
// if (rank==0) { PV_fclose(resultPvpStream); }
// assert(numParams==20);
// if (rank==0) {
// int resultFrameNumber = params[INDEX_NBANDS];
// char * basename = strrchr(imageFile, '/');
// if (basename==NULL) { basename=imageFile; } else { basename++; }
// basename = strdup(basename);
// char * dot = strrchr(basename, '.');
// if (dot) { *dot = '\0'; } // delete extension
// std::stringstream montagePath("");
// montagePath << heatMapMontageDir << "/" << basename << ".png";
// free(basename);
// std::cout << "output file is " << montagePath.str() << std::endl;
//
// if (octavepid>0)
// {
// int waitstatus;
// int waitprocess = waitpid(octavepid, &waitstatus, 0);
// if (waitprocess < 0 && errno != ECHILD)
// {
// fprintf(stderr, "waitpid failed returning %d: %s (%d)\n", waitprocess, strerror(errno), errno);
// exit(EXIT_FAILURE);
// }
// octavepid = 0;
// }
// fflush(stdout); // so that unflushed buffer isn't copied to child process
// octavepid = fork();
// if (octavepid < 0)
// {
// fprintf(stderr, "fork() error: %s\n", strerror(errno));
// exit(EXIT_FAILURE);
// }
// else if (octavepid==0) {
// /* child process */
// std::stringstream octavecommandstream("");
// octavecommandstream << octaveCommand <<
// " --eval 'load CurrentModel/ConfidenceTables/confidenceTable.mat; heatMapMontage(" <<
// "\"" << imagePvpFile << "\"" << ", " <<
// "\"" << resultPvpFile << "\"" << ", " <<
// "\"" << PV_DIR << "/mlab/util" << "\"" << ", " <<
// imageFrameNumber << ", " <<
// resultFrameNumber << ", " <<
// "confidenceTable, " <<
// "\"" << classNames << "\"" << ", " <<
// "\"" << resultTextFile << "\"" << ", " <<
// evalCategoryIndices << ", " <<
// displayCategoryIndices << ", " <<
// highlightThreshold << ", " <<
// heatMapThreshold << ", " <<
// heatMapMaximum << ", " <<
// drawBoundingBoxes << ", " <<
// boundingBoxThickness << ", " <<
// dbscanEps << ", " <<
// dbscanDensity << ", " <<
// "\"" << montagePath.str() << "\"" << ", " <<
// "\"" << displayCommand << "\"" <<
// ");'" <<
// " >> " << octaveLogFile << " 2>&1";
// std::ofstream octavelogstream;
// octavelogstream.open(octaveLogFile, std::fstream::out | std::fstream::app);
// octavelogstream << "Calling octave with the command\n";
// octavelogstream << octavecommandstream.str() << "\n";
// octavelogstream.close();
// int systemstatus = system(octavecommandstream.str().c_str()); // Analysis of the result of the current frame
// octavelogstream.open(octaveLogFile, std::fstream::out | std::fstream::app);
// octavelogstream << "Octave heatMapMontage command returned " << systemstatus << "\n";
// octavelogstream.close();
//
// exit(EXIT_SUCCESS); /* child process exits */
// }
// else {
// /* parent process */
// }
// }
//
free(imageFile);
imageFile = getImageFileName(hc->icCommunicator());
}
delete hc;
free(imageFile);
delete customGroupHandler[0];
delete pv_init;
return status==PV_SUCCESS ? EXIT_SUCCESS : EXIT_FAILURE;
}
bool wxGISServerApp::OnInit()
{
#ifdef wxUSE_SNGLINST_CHECKER
m_pChecker = new wxSingleInstanceChecker(wxT("wxgisserverapp"));
if ( m_pChecker->IsAnotherRunning() )
{
wxLogError(_("Another program instance is already running, aborting."));
wxDELETE( m_pChecker ); // OnExit() won't be called if we return false
return false;
}
#endif
m_oConfig = GetConfig();
if(!m_oConfig.IsOk())
return false;
//create application
m_pServer = new wxGISServer();
SetApplication(m_pServer);
//setup loging
wxString sLogDir = m_oConfig.GetLogDir();
//if(!m_pServer->SetupLog(sLogDir))
// return;
//setup locale
wxString sLocale = m_oConfig.GetLocale();
wxString sLocaleDir = m_oConfig.GetLocaleDir();
if(!m_pServer->SetupLoc(sLocale, sLocaleDir))
return false;
//setup sys
wxString sSysDir = m_oConfig.GetSysDir();
//if(!m_pServer->SetupSys(sSysDir))
// return;
//setup debug
bool bDebugMode = m_oConfig.GetDebugMode();
//m_pServer->SetDebugMode(bDebugMode);
//some default GDAL
wxString sGDALCacheMax = m_oConfig.Read(enumGISHKCU, wxString(wxT("wxGISCommon/GDAL/cachemax")), wxString(wxT("128")));
CPLSetConfigOption( "GDAL_CACHEMAX", sGDALCacheMax.mb_str() );
CPLSetConfigOption ( "LIBKML_USE_DOC.KML", "no" );
//GDAL_MAX_DATASET_POOL_SIZE
//OGR_ARC_STEPSIZE
OGRRegisterAll();
GDALAllRegister();
#ifdef __WXMSW__
wxLogDebug(wxT("wxSocketBase::Initialize"));
wxSocketBase::Initialize();
#endif
//store values
m_oConfig.SetLogDir(sLogDir);
m_oConfig.SetLocale(sLocale);
m_oConfig.SetLocaleDir(sLocaleDir);
m_oConfig.SetSysDir(sSysDir);
m_oConfig.SetDebugMode(bDebugMode);
//gdal
m_oConfig.Write(enumGISHKCU, wxString(wxT("wxGISCommon/GDAL/cachemax")), sGDALCacheMax);
wxString sKey(wxT("wxGISCommon/libs"));
//load libs
wxXmlNode* pLibsNode = m_oConfig.GetConfigNode(enumGISHKCU, sKey);
if(pLibsNode)
LoadLibs(pLibsNode);
pLibsNode = m_oConfig.GetConfigNode(enumGISHKLM, sKey);
if(pLibsNode)
LoadLibs(pLibsNode);
//send interesting things to console
return wxAppConsole::OnInit();
//return true;
}
int QgsNineCellFilter::processRaster( QProgressDialog* p )
{
GDALAllRegister();
//open input file
int xSize, ySize;
GDALDatasetH inputDataset = openInputFile( xSize, ySize );
if ( inputDataset == NULL )
{
return 1; //opening of input file failed
}
//output driver
GDALDriverH outputDriver = openOutputDriver();
if ( outputDriver == 0 )
{
return 2;
}
GDALDatasetH outputDataset = openOutputFile( inputDataset, outputDriver );
if ( outputDataset == NULL )
{
return 3; //create operation on output file failed
}
//open first raster band for reading (operation is only for single band raster)
GDALRasterBandH rasterBand = GDALGetRasterBand( inputDataset, 1 );
if ( rasterBand == NULL )
{
GDALClose( inputDataset );
GDALClose( outputDataset );
return 4;
}
mInputNodataValue = GDALGetRasterNoDataValue( rasterBand, NULL );
GDALRasterBandH outputRasterBand = GDALGetRasterBand( outputDataset, 1 );
if ( outputRasterBand == NULL )
{
GDALClose( inputDataset );
GDALClose( outputDataset );
return 5;
}
//try to set -9999 as nodata value
GDALSetRasterNoDataValue( outputRasterBand, -9999 );
mOutputNodataValue = GDALGetRasterNoDataValue( outputRasterBand, NULL );
if ( ySize < 3 ) //we require at least three rows (should be true for most datasets)
{
GDALClose( inputDataset );
GDALClose( outputDataset );
return 6;
}
//keep only three scanlines in memory at a time
float* scanLine1 = ( float * ) CPLMalloc( sizeof( float ) * xSize );
float* scanLine2 = ( float * ) CPLMalloc( sizeof( float ) * xSize );
float* scanLine3 = ( float * ) CPLMalloc( sizeof( float ) * xSize );
float* resultLine = ( float * ) CPLMalloc( sizeof( float ) * xSize );
if ( p )
{
p->setMaximum( ySize );
}
//values outside the layer extent (if the 3x3 window is on the border) are sent to the processing method as (input) nodata values
for ( int i = 0; i < ySize; ++i )
{
if ( p )
{
p->setValue( i );
}
if ( p && p->wasCanceled() )
{
break;
}
if ( i == 0 )
{
//fill scanline 1 with (input) nodata for the values above the first row and feed scanline2 with the first row
for ( int a = 0; a < xSize; ++a )
{
scanLine1[a] = mInputNodataValue;
}
GDALRasterIO( rasterBand, GF_Read, 0, 0, xSize, 1, scanLine2, xSize, 1, GDT_Float32, 0, 0 );
}
else
{
//normally fetch only scanLine3 and release scanline 1 if we move forward one row
CPLFree( scanLine1 );
scanLine1 = scanLine2;
scanLine2 = scanLine3;
scanLine3 = ( float * ) CPLMalloc( sizeof( float ) * xSize );
}
if ( i == ySize - 1 ) //fill the row below the bottom with nodata values
{
for ( int a = 0; a < xSize; ++a )
{
scanLine3[a] = mInputNodataValue;
}
}
else
{
GDALRasterIO( rasterBand, GF_Read, 0, i + 1, xSize, 1, scanLine3, xSize, 1, GDT_Float32, 0, 0 );
}
for ( int j = 0; j < xSize; ++j )
{
if ( j == 0 )
{
resultLine[j] = processNineCellWindow( &mInputNodataValue, &scanLine1[j], &scanLine1[j+1], &mInputNodataValue, &scanLine2[j],
&scanLine2[j+1], &mInputNodataValue, &scanLine3[j], &scanLine3[j+1] );
}
else if ( j == xSize - 1 )
{
resultLine[j] = processNineCellWindow( &scanLine1[j-1], &scanLine1[j], &mInputNodataValue, &scanLine2[j-1], &scanLine2[j],
&mInputNodataValue, &scanLine3[j-1], &scanLine3[j], &mInputNodataValue );
}
else
{
resultLine[j] = processNineCellWindow( &scanLine1[j-1], &scanLine1[j], &scanLine1[j+1], &scanLine2[j-1], &scanLine2[j],
&scanLine2[j+1], &scanLine3[j-1], &scanLine3[j], &scanLine3[j+1] );
}
}
GDALRasterIO( outputRasterBand, GF_Write, 0, i, xSize, 1, resultLine, xSize, 1, GDT_Float32, 0, 0 );
}
if ( p )
{
p->setValue( ySize );
}
CPLFree( resultLine );
CPLFree( scanLine1 );
CPLFree( scanLine2 );
CPLFree( scanLine3 );
GDALClose( inputDataset );
if ( p && p->wasCanceled() )
{
//delete the dataset without closing (because it is faster)
GDALDeleteDataset( outputDriver, TO8F( mOutputFile ) );
return 7;
}
GDALClose( outputDataset );
return 0;
}
bool Shape::save(const std::string& filename) {
if (shapeType == -1) {
std::cout << "Shape type is not set." << std::endl;
return false;
}
if (shapeObjects.size() == 0) {
std::cout << "No shape exists." << std::endl;
return false;
}
const char *pszDriverName = "ESRI Shapefile";
GDALDriver *poDriver;
GDALAllRegister();
poDriver = GetGDALDriverManager()->GetDriverByName(pszDriverName);
if (poDriver == NULL) {
printf("%s driver not available.\n", pszDriverName);
return false;
}
GDALDataset *poDS;
poDS = poDriver->Create(filename.c_str(), 0, 0, 0, GDT_Unknown, NULL);
if (poDS == NULL) {
printf("Creation of output file failed.\n");
return false;
}
OGRLayer *poLayer;
if (shapeType == wkbPoint) {
poLayer = poDS->CreateLayer("point_out", NULL, wkbPoint, NULL);
}
else if (shapeType == wkbLineString) {
poLayer = poDS->CreateLayer("point_out", NULL, wkbLineString, NULL);
}
else if (shapeType == wkbPolygon) {
poLayer = poDS->CreateLayer("point_out", NULL, wkbPolygon, NULL);
}
if (poLayer == NULL) {
printf("Layer creation failed.\n");
return false;
}
for (auto it = shapeObjects[0].attributes.begin(); it != shapeObjects[0].attributes.end(); ++it) {
OGRFieldDefn oField(it->first.c_str(), static_cast<OGRFieldType>(it->second.type));
if (it->second.type == OFTString) {
oField.SetWidth(it->second.stringValue().size());
}
if (poLayer->CreateField(&oField) != OGRERR_NONE) {
printf("Creating Name field failed.\n");
return false;
}
}
for (int i = 0; i < shapeObjects.size(); ++i) {
if (shapeObjects[i].parts.size() == 0) continue;
OGRFeature *poFeature;
poFeature = OGRFeature::CreateFeature(poLayer->GetLayerDefn());
// 属性をセット
for (auto it = shapeObjects[i].attributes.begin(); it != shapeObjects[i].attributes.end(); ++it) {
poFeature->SetField(it->first.c_str(), it->second.stringValue().c_str());
}
// ジオメトリ情報をセット
if (shapeType == wkbPoint) {
OGRPoint point;
point.setX(shapeObjects[i].parts[0].points[0].x);
point.setY(shapeObjects[i].parts[0].points[0].y);
point.setZ(shapeObjects[i].parts[0].points[0].z);
poFeature->SetGeometry(&point);
}
else if (shapeType == wkbLineString) {
OGRLineString lineString;
for (int k = 0; k < shapeObjects[i].parts[0].points.size(); ++k) {
lineString.addPoint(shapeObjects[i].parts[0].points[k].x, shapeObjects[i].parts[0].points[k].y, shapeObjects[i].parts[0].points[k].z);
}
poFeature->SetGeometry(&lineString);
}
else if (shapeType == wkbPolygon) {
OGRPolygon polygon;
for (int j = 0; j < shapeObjects[i].parts.size(); ++j) {
OGRLinearRing linearRing;
for (int k = 0; k < shapeObjects[i].parts[j].points.size(); ++k) {
linearRing.addPoint(shapeObjects[i].parts[j].points[k].x, shapeObjects[i].parts[j].points[k].y, shapeObjects[i].parts[j].points[k].z);
}
polygon.addRing(&linearRing);
}
poFeature->SetGeometry(&polygon);
}
if (poLayer->CreateFeature(poFeature) != OGRERR_NONE) {
printf("Failed to create feature in shapefile.\n");
return false;
}
OGRFeature::DestroyFeature(poFeature);
}
GDALClose(poDS);
return true;
}
int main(int argc, char *argv[]){
GDALDataset *poDataset;
GDALAllRegister();
if(argc != 3){
std::cout << "usage:\n" << argv[0] << " src_file dest_file\n";
exit(0);
}
const std::string name = argv[1];
const std::string destName = argv[2];
poDataset = (GDALDataset *) GDALOpen(name.c_str(), GA_ReadOnly );
if( poDataset == NULL ){
std::cout << "Failed to open " << name << "\n";
}else{
const char *pszFormat = "GTiff";
char **papszMetadata;
GDALDriver *poDriver;
poDriver = GetGDALDriverManager()->GetDriverByName(pszFormat);
if( poDriver == NULL ){
std::cout << "Cant open driver\n";
exit(1);
}
papszMetadata = GDALGetMetadata(poDriver, NULL);
if( !CSLFetchBoolean(papszMetadata, GDAL_DCAP_CREATE, FALSE)){
std::cout << "Create Method not suported!\n";
}
if( !CSLFetchBoolean( papszMetadata, GDAL_DCAP_CREATECOPY, FALSE ) ){
std::cout << "CreateCopy() method not suported.\n";
}
char **papszOptions = NULL;
std::cout << "Reading file " << name << "\n";
std::cout << "x= " << poDataset->GetRasterXSize()
<< ", h=" << poDataset->GetRasterYSize() <<
", bands= " << poDataset->GetRasterCount() << "\n";
GDALRasterBand *data;
data = poDataset->GetRasterBand(1);
GDALDataType type = data->GetRasterDataType();
int size = data->GetXSize()*data->GetYSize();
std::cout << "size=" << size << " , w*h = " << poDataset->GetRasterXSize()*poDataset->GetRasterYSize() << "\n";
float *buffer;
buffer = (float *) CPLMalloc(sizeof(float)*size);
data->RasterIO(GF_Read, 0, 0, data->GetXSize(), data->GetYSize(), buffer, data->GetXSize(), data->GetYSize(), GDT_Float32, 0, 0 );
// Metadata,
double geot[6];
poDataset->GetGeoTransform(geot);
unsigned int i;
float max=0, min=0;
for(i=0; i<size; i++){
if(max < buffer[i]){
max = buffer[i];
}
if(min > buffer[i]){
min = buffer[i];
}
}
float range = max - min;
std::cout << "range=" << range << ", max=" << max << ", min=" << min << "\n";
std::map<float, unsigned int> counter;
std::fstream json(destName.c_str(), std::ios::trunc | std::ios::out);
json << "{\"w\":" << poDataset->GetRasterXSize() << ",\"h\":" << poDataset->GetRasterXSize() << ",\"data\":[";
for(i=0; i<size; i++){
float value = buffer[i];
json << value;
if (i!=size-1) {
json << ",";
}
}
json << "]}";
json.close();
GDALClose(poDataset);
std::string cmd = "bzip2 " + destName;
system(cmd.c_str());
}
exit(0);
}
int main( int nArgc, char ** papszArgv )
{
int bQuiet = FALSE;
const char *pszDataSource = NULL;
GNMGFID nFromFID = -1;
GNMGFID nToFID = -1;
int nK = 1;
const char *pszDataset = NULL;
const char *pszFormat = "ESRI Shapefile";
const char *pszLayer = NULL;
GNMNetwork *poDS = NULL;
OGRLayer* poResultLayer = NULL;
char **papszDSCO = NULL, **papszLCO = NULL, **papszALO = NULL;
operation stOper = op_unknown;
int nRet = 0;
// Check strict compilation and runtime library version as we use C++ API
if (! GDAL_CHECK_VERSION(papszArgv[0]))
exit(1);
EarlySetConfigOptions(nArgc, papszArgv);
/* -------------------------------------------------------------------- */
/* Register format(s). */
/* -------------------------------------------------------------------- */
GDALAllRegister();
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
nArgc = GDALGeneralCmdLineProcessor( nArgc, &papszArgv, GDAL_OF_GNM );
if( nArgc < 1 )
{
exit( -nArgc );
}
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[1], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
CSLDestroy( papszArgv );
return 0;
}
else if( EQUAL(papszArgv[iArg],"--help") )
{
Usage();
}
else if ( EQUAL(papszArgv[iArg], "--long-usage") )
{
Usage(FALSE);
}
else if( EQUAL(papszArgv[iArg],"-q") || EQUAL(papszArgv[iArg],"-quiet") )
{
bQuiet = TRUE;
}
else if( EQUAL(papszArgv[iArg],"dijkstra") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
stOper = op_dijkstra;
nFromFID = atoi(papszArgv[++iArg]);
nToFID = atoi(papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg],"kpaths") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(3);
stOper = op_kpaths;
nFromFID = atoi(papszArgv[++iArg]);
nToFID = atoi(papszArgv[++iArg]);
nK = atoi(papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg],"resource") )
{
stOper = op_resource;
}
else if( EQUAL(papszArgv[iArg],"-ds") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszDataset = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-f") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszFormat = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-l") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszLayer = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-dsco") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszDSCO = CSLAddString(papszDSCO, papszArgv[++iArg] );
}
else if( EQUAL(papszArgv[iArg],"-lco") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszLCO = CSLAddString(papszLCO, papszArgv[++iArg] );
}
else if( EQUAL(papszArgv[iArg],"-alo") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszALO = CSLAddString(papszALO, papszArgv[++iArg] );
}
else if( papszArgv[iArg][0] == '-' )
{
Usage(CPLSPrintf("Unknown option name '%s'", papszArgv[iArg]));
}
else if( pszDataSource == NULL )
pszDataSource = papszArgv[iArg];
}
// do the work ////////////////////////////////////////////////////////////////
if(stOper == op_dijkstra)
{
if(pszDataSource == NULL)
Usage("No network dataset provided");
if(nFromFID == -1 || nToFID == -1)
Usage("Invalid input from or to identificators");
// open
poDS = (GNMNetwork*) GDALOpenEx( pszDataSource,
GDAL_OF_UPDATE | GDAL_OF_GNM, NULL, NULL, NULL );
if(NULL == poDS)
{
fprintf( stderr, "\nFailed to open network at %s\n", pszDataSource);
nRet = 1;
goto exit;
}
poResultLayer = poDS->GetPath(nFromFID, nToFID, GATDijkstraShortestPath,
papszALO);
if(NULL == pszDataset)
{
ReportOnLayer(poResultLayer, bQuiet == FALSE);
}
else
{
if(CreateAndFillOutputDataset(poResultLayer, pszDataset, pszFormat,
pszLayer, papszDSCO, papszLCO, bQuiet)
!= OGRERR_NONE)
{
nRet = 1;
goto exit;
}
}
}
else if(stOper == op_kpaths)
{
if(pszDataSource == NULL)
Usage("No network dataset provided");
if(nFromFID == -1 || nToFID == -1)
Usage("Invalid input from or to identificators");
// open
poDS = (GNMNetwork*) GDALOpenEx( pszDataSource,
GDAL_OF_UPDATE | GDAL_OF_GNM, NULL, NULL, NULL );
if(NULL == poDS)
{
fprintf( stderr, "\nFailed to open network at %s\n", pszDataSource);
nRet = 1;
goto exit;
}
if(CSLFindName(papszALO, GNM_MD_NUM_PATHS) == -1)
{
CPLDebug("GNM", "No K in options, add %d value", nK);
papszALO = CSLAddNameValue(papszALO, GNM_MD_NUM_PATHS,
CPLSPrintf("%d", nK));
}
poResultLayer = poDS->GetPath(nFromFID, nToFID, GATKShortestPath,
papszALO);
if(NULL == pszDataset)
{
ReportOnLayer(poResultLayer, bQuiet == FALSE);
}
else
{
if(CreateAndFillOutputDataset(poResultLayer, pszDataset, pszFormat,
pszLayer, papszDSCO, papszLCO, bQuiet)
!= OGRERR_NONE)
{
nRet = 1;
goto exit;
}
}
}
else if(stOper == op_resource)
{
if(pszDataSource == NULL)
Usage("No network dataset provided");
// open
poDS = (GNMNetwork*) GDALOpenEx( pszDataSource,
GDAL_OF_UPDATE | GDAL_OF_GNM, NULL, NULL, NULL );
if(NULL == poDS)
{
fprintf( stderr, "\nFailed to open network at %s\n", pszDataSource);
nRet = 1;
goto exit;
}
poResultLayer = poDS->GetPath(nFromFID, nToFID, GATConnectedComponents,
papszALO);
if(NULL == pszDataset)
{
ReportOnLayer(poResultLayer, bQuiet == FALSE);
}
else
{
if(CreateAndFillOutputDataset(poResultLayer, pszDataset, pszFormat,
pszLayer, papszDSCO, papszLCO, bQuiet)
!= OGRERR_NONE)
{
nRet = 1;
goto exit;
}
}
}
else
{
printf("\nNeed an operation. See help what you can do with gnmanalyse:\n");
Usage();
}
exit:
CSLDestroy(papszDSCO);
CSLDestroy(papszLCO);
CSLDestroy(papszALO);
CSLDestroy( papszArgv );
if(poResultLayer != NULL)
poDS->ReleaseResultSet(poResultLayer);
if( poDS != NULL )
GDALClose( (GDALDatasetH)poDS );
GDALDestroyDriverManager();
return nRet;
}
int main( int argc, char ** argv )
{
bool bGotSRS = false;
bool bPretty = false;
bool bValidate = false;
bool bFindEPSG = false;
int nEPSGCode = -1;
const char *pszInput = NULL;
const char *pszOutputType = "default";
OGRSpatialReference oSRS;
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(argv[0]))
exit(1);
EarlySetConfigOptions(argc, argv);
/* -------------------------------------------------------------------- */
/* Register standard GDAL and OGR drivers. */
/* -------------------------------------------------------------------- */
GDALAllRegister();
/* -------------------------------------------------------------------- */
/* Register standard GDAL drivers, and process generic GDAL */
/* command options. */
/* -------------------------------------------------------------------- */
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
for( int i = 1; i < argc; i++ )
{
CPLDebug( "gdalsrsinfo", "got arg #%d : [%s]", i, argv[i] );
if( EQUAL(argv[i], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
CSLDestroy( argv );
return 0;
}
else if( EQUAL(argv[i], "-h") || EQUAL(argv[i], "--help") )
Usage();
else if( EQUAL(argv[i], "-e") )
bFindEPSG = true;
else if( EQUAL(argv[i], "-o") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszOutputType = argv[++i];
}
else if( EQUAL(argv[i], "-p") )
bPretty = true;
else if( EQUAL(argv[i], "-V") )
bValidate = true;
else if( argv[i][0] == '-' )
{
Usage(CPLSPrintf("Unknown option name '%s'", argv[i]));
}
else
pszInput = argv[i];
}
if ( pszInput == NULL ) {
CSLDestroy( argv );
Usage("No input specified.");
}
/* Search for SRS */
/* coverity[tainted_data] */
bGotSRS = FindSRS( pszInput, oSRS ) == TRUE;
CPLDebug( "gdalsrsinfo",
"bGotSRS: %d bValidate: %d pszOutputType: %s bPretty: %d",
static_cast<int>(bGotSRS),
static_cast<int>(bValidate),
pszOutputType,
static_cast<int>(bPretty) );
/* Make sure we got a SRS */
if ( ! bGotSRS ) {
CPLError( CE_Failure, CPLE_AppDefined,
"ERROR - failed to load SRS definition from %s",
pszInput );
}
else {
/* Find EPSG code - experimental */
if ( EQUAL(pszOutputType,"epsg") )
bFindEPSG = true;
if ( bFindEPSG ) {
CPLError( CE_Warning, CPLE_AppDefined,
"EPSG detection is experimental and requires new data files (see bug #4345)" );
nEPSGCode = FindEPSG( oSRS );
/* If found, replace oSRS based on EPSG code */
if(nEPSGCode != -1) {
CPLDebug( "gdalsrsinfo",
"Found EPSG code %d", nEPSGCode );
OGRSpatialReference oSRS2;
if ( oSRS2.importFromEPSG( nEPSGCode ) == OGRERR_NONE )
oSRS = oSRS2;
}
}
/* Validate - not well tested!*/
if ( bValidate ) {
OGRErr eErr = oSRS.Validate( );
if ( eErr != OGRERR_NONE ) {
printf( "\nValidate Fails" );
if ( eErr == OGRERR_CORRUPT_DATA )
printf( " - SRS is not well formed");
else if ( eErr == OGRERR_UNSUPPORTED_SRS )
printf(" - contains non-standard PROJECTION[] values");
printf("\n");
}
else
printf( "\nValidate Succeeds\n" );
}
/* Output */
if ( EQUAL("default", pszOutputType ) ) {
/* does this work in MSVC? */
const char* papszOutputTypes[] =
{ "proj4", "wkt", NULL };
if ( bFindEPSG )
printf("\nEPSG:%d\n",nEPSGCode);
PrintSRSOutputTypes( oSRS, papszOutputTypes );
}
else if ( EQUAL("all", pszOutputType ) ) {
if ( bFindEPSG )
printf("\nEPSG:%d\n\n",nEPSGCode);
const char* papszOutputTypes[] =
{"proj4","wkt","wkt_simple","wkt_noct","wkt_esri","mapinfo","xml",NULL};
PrintSRSOutputTypes( oSRS, papszOutputTypes );
}
else if ( EQUAL("wkt_all", pszOutputType ) ) {
const char* papszOutputTypes[] =
{ "wkt", "wkt_simple", "wkt_noct", "wkt_esri", NULL };
PrintSRSOutputTypes( oSRS, papszOutputTypes );
}
else {
if ( bPretty )
printf( "\n" );
if ( EQUAL(pszOutputType,"epsg") )
printf("EPSG:%d\n",nEPSGCode);
else
PrintSRS( oSRS, pszOutputType, bPretty, FALSE );
if ( bPretty )
printf( "\n" );
}
}
/* cleanup anything left */
GDALDestroyDriverManager();
OGRCleanupAll();
CSLDestroy( argv );
return 0;
}
int main( int argc, char ** argv )
{
GDALDatasetH hSrcDS;
int iY, iX, nOutLevel=0, nXSize, nYSize, iArg, nFillDist=0;
void *pStream;
GInt16 *panData;
const char *pszFilename = NULL;
GDALRasterBandH hSrcBand;
double adfGeoTransform[6];
int bEnableTrim = FALSE;
GInt16 noDataValue = 0;
int bHasNoData;
/* -------------------------------------------------------------------- */
/* Identify arguments. */
/* -------------------------------------------------------------------- */
for( iArg = 1; iArg < argc; iArg++ )
{
if( EQUAL(argv[iArg],"-trim") )
bEnableTrim = TRUE;
else if( EQUAL(argv[iArg],"-fill") )
nFillDist = atoi(argv[++iArg]);
else if( EQUAL(argv[iArg],"-level") )
nOutLevel = atoi(argv[++iArg]);
else
{
if( pszFilename != NULL )
Usage();
pszFilename = argv[iArg];
}
}
if( pszFilename == NULL )
Usage();
/* -------------------------------------------------------------------- */
/* Open input file. */
/* -------------------------------------------------------------------- */
GDALAllRegister();
hSrcDS = GDALOpen( pszFilename, GA_ReadOnly );
if( hSrcDS == NULL )
exit(1);
hSrcBand = GDALGetRasterBand( hSrcDS, 1 );
noDataValue = (GInt16)GDALGetRasterNoDataValue(hSrcBand, &bHasNoData);
nXSize = GDALGetRasterXSize( hSrcDS );
nYSize = GDALGetRasterYSize( hSrcDS );
GDALGetGeoTransform( hSrcDS, adfGeoTransform );
/* -------------------------------------------------------------------- */
/* Create output stream. */
/* -------------------------------------------------------------------- */
pStream = DTEDCreatePtStream( ".", nOutLevel );
if( pStream == NULL )
exit( 1 );
/* -------------------------------------------------------------------- */
/* Process all the profiles. */
/* -------------------------------------------------------------------- */
panData = (GInt16 *) malloc(sizeof(GInt16) * nXSize);
for( iY = 0; iY < nYSize; iY++ )
{
GDALRasterIO( hSrcBand, GF_Read, 0, iY, nXSize, 1,
panData, nXSize, 1, GDT_Int16, 0, 0 );
if (bHasNoData)
{
for( iX = 0; iX < nXSize; iX++ )
{
if (panData[iX] == noDataValue)
panData[iX] = DTED_NODATA_VALUE;
}
}
for( iX = 0; iX < nXSize; iX++ )
{
DTEDWritePt( pStream,
adfGeoTransform[0]
+ adfGeoTransform[1] * (iX + 0.5)
+ adfGeoTransform[2] * (iY + 0.5),
adfGeoTransform[3]
+ adfGeoTransform[4] * (iX + 0.5)
+ adfGeoTransform[5] * (iY + 0.5),
panData[iX] );
}
}
free( panData );
/* -------------------------------------------------------------------- */
/* Cleanup. */
/* -------------------------------------------------------------------- */
if( bEnableTrim )
DTEDPtStreamTrimEdgeOnlyTiles( pStream );
if( nFillDist > 0 )
DTEDFillPtStream( pStream, nFillDist );
DTEDClosePtStream( pStream );
GDALClose( hSrcDS );
exit( 0 );
}
const QString OmgGdal::Gdal2Ascii(const QString theFileName)
{
std::cout << "Running gdal to ascii conversion..." << std::endl;
QFileInfo myFileInfo(theFileName);
QString myExt("asc");
QString myOutFileName(QDir::convertSeparators(myFileInfo.dirPath(true)+"/"+myFileInfo.baseName() + "." + myExt));
QFile myFile( myOutFileName );
if ( !myFile.open( IO_WriteOnly ) )
{
printf("Opening output file for write failed");
return QString("");
}
QTextStream myStream( &myFile );
GDALAllRegister();
GDALDataset *gdalDataset = (GDALDataset *) GDALOpen( theFileName.local8Bit(), GA_ReadOnly );
if ( gdalDataset == NULL )
{
std::cout << "Error couldn't open file: " << theFileName << std::endl;
return QString("");
}
//Write the ascii headers
myStream << getAsciiHeader(theFileName);
//assume to be working with first band in dataset only
GDALRasterBand *myGdalBand = gdalDataset->GetRasterBand( 1 );
//find out the name of the band if any
QString myColorInterpretation = GDALGetColorInterpretationName(myGdalBand->GetColorInterpretation());
// get the dimensions of the raster
int myColsInt = myGdalBand->GetXSize();
int myRowsInt = myGdalBand->GetYSize();
double myNullValue=myGdalBand->GetNoDataValue();
//allocate a buffer to hold one row of ints
int myAllocationSizeInt = sizeof(uint)*myColsInt;
uint * myScanlineAllocInt = (uint*) CPLMalloc(myAllocationSizeInt);
for (int myCurrentRowInt=0; myCurrentRowInt < myRowsInt;myCurrentRowInt++)
{
//get a scanline
CPLErr myResult = myGdalBand->RasterIO(
GF_Read, 0,
myCurrentRowInt,
myColsInt,
1,
myScanlineAllocInt,
myColsInt,
1,
GDT_UInt32,
0,
0 );
for (int myCurrentColInt=0; myCurrentColInt < myColsInt; myCurrentColInt++)
{
//get the nth element from the current row
double myDouble=myScanlineAllocInt[myCurrentColInt];
myStream << myDouble << " "; //pixel value
} //end of column wise loop
myStream << "\r\n"; //dos style new line
} //end of row wise loop
CPLFree(myScanlineAllocInt);
myFile.close();
std::cout << "The output ascii file is: " << myOutFileName << std::endl;
return myOutFileName;
}
int main( int argc, char ** argv )
{
int i;
int bGotSRS = FALSE;
int bPretty = FALSE;
int bValidate = FALSE;
int bFindEPSG = FALSE;
int nEPSGCode = -1;
const char *pszInput = NULL;
const char *pszOutputType = "default";
OGRSpatialReference oSRS;
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(argv[0]))
exit(1);
/* Must process GDAL_SKIP before GDALAllRegister(), but we can't call */
/* GDALGeneralCmdLineProcessor before it needs the drivers to be registered */
/* for the --format or --formats options */
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i],"--config") && i + 2 < argc && EQUAL(argv[i + 1], "GDAL_SKIP") )
{
CPLSetConfigOption( argv[i+1], argv[i+2] );
i += 2;
}
}
/* -------------------------------------------------------------------- */
/* Register standard GDAL and OGR drivers. */
/* -------------------------------------------------------------------- */
GDALAllRegister();
#ifdef OGR_ENABLED
OGRRegisterAll();
#endif
/* -------------------------------------------------------------------- */
/* Process --formats option. */
/* Code copied from gcore/gdal_misc.cpp and ogr/ogrutils.cpp. */
/* This is not ideal, but is best for more descriptive output and */
/* we don't want to call OGRGeneralCmdLineProcessor(). */
/* -------------------------------------------------------------------- */
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i], "--formats") )
{
int iDr;
/* GDAL formats */
printf( "Supported Raster Formats:\n" );
for( iDr = 0; iDr < GDALGetDriverCount(); iDr++ )
{
GDALDriverH hDriver = GDALGetDriver(iDr);
const char *pszRWFlag, *pszVirtualIO;
if( GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL ) )
pszRWFlag = "rw+";
else if( GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATECOPY,
NULL ) )
pszRWFlag = "rw";
else
pszRWFlag = "ro";
if( GDALGetMetadataItem( hDriver, GDAL_DCAP_VIRTUALIO, NULL) )
pszVirtualIO = "v";
else
pszVirtualIO = "";
printf( " %s (%s%s): %s\n",
GDALGetDriverShortName( hDriver ),
pszRWFlag, pszVirtualIO,
GDALGetDriverLongName( hDriver ) );
}
/* OGR formats */
#ifdef OGR_ENABLED
printf( "\nSupported Vector Formats:\n" );
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
for( iDr = 0; iDr < poR->GetDriverCount(); iDr++ )
{
OGRSFDriver *poDriver = poR->GetDriver(iDr);
if( poDriver->TestCapability( ODrCCreateDataSource ) )
printf( " -> \"%s\" (read/write)\n",
poDriver->GetName() );
else
printf( " -> \"%s\" (readonly)\n",
poDriver->GetName() );
}
#endif
exit(1);
}
}
/* -------------------------------------------------------------------- */
/* Register standard GDAL drivers, and process generic GDAL */
/* command options. */
/* -------------------------------------------------------------------- */
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
for( i = 1; i < argc; i++ )
{
CPLDebug( "gdalsrsinfo", "got arg #%d : [%s]", i, argv[i] );
if( EQUAL(argv[i], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(argv[i], "-h") )
Usage();
else if( EQUAL(argv[i], "-e") )
bFindEPSG = TRUE;
else if( EQUAL(argv[i], "-o") && i < argc - 1)
pszOutputType = argv[++i];
else if( EQUAL(argv[i], "-p") )
bPretty = TRUE;
else if( EQUAL(argv[i], "-V") )
bValidate = TRUE;
else if( argv[i][0] == '-' )
{
CSLDestroy( argv );
Usage();
}
else
pszInput = argv[i];
}
if ( pszInput == NULL ) {
CSLDestroy( argv );
Usage();
}
/* Search for SRS */
bGotSRS = FindSRS( pszInput, oSRS );
CPLDebug( "gdalsrsinfo",
"bGotSRS: %d bValidate: %d pszOutputType: %s bPretty: %d",
bGotSRS, bValidate, pszOutputType, bPretty );
/* Make sure we got a SRS */
if ( ! bGotSRS ) {
CPLError( CE_Failure, CPLE_AppDefined,
"ERROR - failed to load SRS definition from %s",
pszInput );
}
else {
/* Find EPSG code - experimental */
if ( EQUAL(pszOutputType,"epsg") )
bFindEPSG = TRUE;
if ( bFindEPSG ) {
CPLError( CE_Warning, CPLE_AppDefined,
"EPSG detection is experimental and requires new data files (see bug #4345)" );
nEPSGCode = FindEPSG( oSRS );
/* If found, replace oSRS based on EPSG code */
if(nEPSGCode != -1) {
CPLDebug( "gdalsrsinfo",
"Found EPSG code %d", nEPSGCode );
OGRSpatialReference oSRS2;
if ( oSRS2.importFromEPSG( nEPSGCode ) == OGRERR_NONE )
oSRS = oSRS2;
}
}
/* Validate - not well tested!*/
if ( bValidate ) {
OGRErr eErr = oSRS.Validate( );
if ( eErr != OGRERR_NONE ) {
printf( "\nValidate Fails" );
if ( eErr == OGRERR_CORRUPT_DATA )
printf( " - SRS is not well formed");
else if ( eErr == OGRERR_UNSUPPORTED_SRS )
printf(" - contains non-standard PROJECTION[] values");
printf("\n");
}
else
printf( "\nValidate Succeeds\n" );
}
/* Output */
if ( EQUAL("default", pszOutputType ) ) {
/* does this work in MSVC? */
const char* papszOutputTypes[] =
{ "proj4", "wkt", NULL };
if ( bFindEPSG )
printf("\nEPSG:%d\n",nEPSGCode);
PrintSRSOutputTypes( oSRS, papszOutputTypes );
}
else if ( EQUAL("all", pszOutputType ) ) {
if ( bFindEPSG )
printf("\nEPSG:%d\n\n",nEPSGCode);
const char* papszOutputTypes[] =
{"proj4","wkt","wkt_simple","wkt_noct","wkt_esri","mapinfo","xml",NULL};
PrintSRSOutputTypes( oSRS, papszOutputTypes );
}
else if ( EQUAL("wkt_all", pszOutputType ) ) {
const char* papszOutputTypes[] =
{ "wkt", "wkt_simple", "wkt_noct", "wkt_esri", NULL };
PrintSRSOutputTypes( oSRS, papszOutputTypes );
}
else {
if ( bPretty )
printf( "\n" );
if ( EQUAL(pszOutputType,"epsg") )
printf("EPSG:%d\n",nEPSGCode);
else
PrintSRS( oSRS, pszOutputType, bPretty, FALSE );
if ( bPretty )
printf( "\n" );
}
}
/* cleanup anything left */
GDALDestroyDriverManager();
#ifdef OGR_ENABLED
OGRCleanupAll();
#endif
CSLDestroy( argv );
return 0;
}
// Slot called when the menu item is triggered
// If you created more menu items / toolbar buttons in initiGui, you should
// create a separate handler for each action - this single run() method will
// not be enough
void Heatmap::run()
{
HeatmapGui d( mQGisIface->mainWindow(), QgisGui::ModalDialogFlags, &mSessionSettings );
//check that dialog found a suitable vector layer
if ( !d.inputVectorLayer() )
{
mQGisIface->messageBar()->pushMessage( tr( "Layer not found" ), tr( "The heatmap plugin requires at least one point vector layer" ), QgsMessageBar::INFO, mQGisIface->messageTimeout() );
return;
}
if ( d.exec() != QDialog::Accepted )
{
return;
}
QgsVectorLayer* inputLayer = d.inputVectorLayer();
// Get the required data from the dialog
QgsRectangle myBBox = d.bbox();
int columns = d.columns();
int rows = d.rows();
double cellsize = d.cellSizeX(); // or d.cellSizeY(); both have the same value
mDecay = d.decayRatio();
KernelShape kernelShape = d.kernelShape();
OutputValues valueType = d.outputValues();
//is input layer multipoint?
bool isMultiPoint = inputLayer->wkbType() == Qgis::WKBMultiPoint || inputLayer->wkbType() == Qgis::WKBMultiPoint25D;
// Getting the rasterdataset in place
GDALAllRegister();
GDALDriverH myDriver = GDALGetDriverByName( d.outputFormat().toUtf8() );
if ( !myDriver )
{
mQGisIface->messageBar()->pushMessage( tr( "GDAL driver error" ), tr( "Cannot open the driver for the specified format" ), QgsMessageBar::WARNING, mQGisIface->messageTimeout() );
return;
}
double geoTransform[6] = { myBBox.xMinimum(), cellsize, 0, myBBox.yMinimum(), 0, cellsize };
GDALDatasetH emptyDataset = GDALCreate( myDriver, d.outputFilename().toUtf8(), columns, rows, 1, GDT_Float32, nullptr );
GDALSetGeoTransform( emptyDataset, geoTransform );
// Set the projection on the raster destination to match the input layer
GDALSetProjection( emptyDataset, inputLayer->crs().toWkt().toLocal8Bit().data() );
GDALRasterBandH poBand = GDALGetRasterBand( emptyDataset, 1 );
GDALSetRasterNoDataValue( poBand, NO_DATA );
float* line = ( float * ) CPLMalloc( sizeof( float ) * columns );
for ( int i = 0; i < columns ; i++ )
{
line[i] = NO_DATA;
}
// Write the empty raster
for ( int i = 0; i < rows ; i++ )
{
if ( GDALRasterIO( poBand, GF_Write, 0, i, columns, 1, line, columns, 1, GDT_Float32, 0, 0 ) != CE_None )
{
QgsDebugMsg( "Raster IO Error" );
}
}
CPLFree( line );
//close the dataset
GDALClose( emptyDataset );
// open the raster in GA_Update mode
GDALDatasetH heatmapDS = GDALOpen( TO8F( d.outputFilename() ), GA_Update );
if ( !heatmapDS )
{
mQGisIface->messageBar()->pushMessage( tr( "Raster update error" ), tr( "Could not open the created raster for updating. The heatmap was not generated." ), QgsMessageBar::WARNING );
return;
}
poBand = GDALGetRasterBand( heatmapDS, 1 );
QgsAttributeList myAttrList;
int rField = 0;
int wField = 0;
// Handle different radius options
double radius;
double radiusToMapUnits = 1;
int myBuffer = 0;
if ( d.variableRadius() )
{
rField = d.radiusField();
myAttrList.append( rField );
QgsDebugMsg( QString( "Radius Field index received: %1" ).arg( rField ) );
// If not using map units, then calculate a conversion factor to convert the radii to map units
if ( d.radiusUnit() == HeatmapGui::LayerUnits )
{
radiusToMapUnits = mapUnitsOf( 1, inputLayer->crs() );
}
}
else
{
radius = d.radius(); // radius returned by d.radius() is already in map units
myBuffer = bufferSize( radius, cellsize );
}
if ( d.weighted() )
{
wField = d.weightField();
myAttrList.append( wField );
}
// This might have attributes or mightnot have attibutes at all
// based on the variableRadius() and weighted()
QgsFeatureIterator fit = inputLayer->getFeatures( QgsFeatureRequest().setSubsetOfAttributes( myAttrList ) );
int totalFeatures = inputLayer->featureCount();
int counter = 0;
QProgressDialog p( tr( "Rendering heatmap..." ), tr( "Abort" ), 0, totalFeatures, mQGisIface->mainWindow() );
p.setWindowTitle( tr( "QGIS" ) );
p.setWindowModality( Qt::ApplicationModal );
p.show();
QgsFeature myFeature;
while ( fit.nextFeature( myFeature ) )
{
counter++;
p.setValue( counter );
QApplication::processEvents();
if ( p.wasCanceled() )
{
mQGisIface->messageBar()->pushMessage( tr( "Heatmap generation aborted" ), tr( "QGIS will now load the partially-computed raster" ), QgsMessageBar::INFO, mQGisIface->messageTimeout() );
break;
}
const QgsGeometry* featureGeometry = myFeature.constGeometry();
if ( !featureGeometry )
{
continue;
}
// convert the geometry to multipoint
QgsMultiPoint multiPoints;
if ( !isMultiPoint )
{
QgsPoint myPoint = featureGeometry->asPoint();
// avoiding any empty points or out of extent points
if (( myPoint.x() < myBBox.xMinimum() ) || ( myPoint.y() < myBBox.yMinimum() )
|| ( myPoint.x() > myBBox.xMaximum() ) || ( myPoint.y() > myBBox.yMaximum() ) )
{
continue;
}
multiPoints << myPoint;
}
else
{
multiPoints = featureGeometry->asMultiPoint();
}
// If radius is variable then fetch it and calculate new pixel buffer size
if ( d.variableRadius() )
{
radius = myFeature.attribute( rField ).toDouble() * radiusToMapUnits;
myBuffer = bufferSize( radius, cellsize );
}
int blockSize = 2 * myBuffer + 1; //Block SIDE would be more appropriate
double weight = 1.0;
if ( d.weighted() )
{
weight = myFeature.attribute( wField ).toDouble();
}
//loop through all points in multipoint
for ( QgsMultiPoint::const_iterator pointIt = multiPoints.constBegin(); pointIt != multiPoints.constEnd(); ++pointIt )
{
// avoiding any empty points or out of extent points
if ((( *pointIt ).x() < myBBox.xMinimum() ) || (( *pointIt ).y() < myBBox.yMinimum() )
|| (( *pointIt ).x() > myBBox.xMaximum() ) || (( *pointIt ).y() > myBBox.yMaximum() ) )
{
continue;
}
// calculate the pixel position
unsigned int xPosition, yPosition;
xPosition = ((( *pointIt ).x() - myBBox.xMinimum() ) / cellsize ) - myBuffer;
yPosition = ((( *pointIt ).y() - myBBox.yMinimum() ) / cellsize ) - myBuffer;
// get the data
float *dataBuffer = ( float * ) CPLMalloc( sizeof( float ) * blockSize * blockSize );
if ( GDALRasterIO( poBand, GF_Read, xPosition, yPosition, blockSize, blockSize,
dataBuffer, blockSize, blockSize, GDT_Float32, 0, 0 ) != CE_None )
{
QgsDebugMsg( "Raster IO Error" );
}
for ( int xp = 0; xp <= myBuffer; xp++ )
{
for ( int yp = 0; yp <= myBuffer; yp++ )
{
double distance = sqrt( pow( xp, 2.0 ) + pow( yp, 2.0 ) );
// is pixel outside search bandwidth of feature?
if ( distance > myBuffer )
{
continue;
}
double pixelValue = weight * calculateKernelValue( distance, myBuffer, kernelShape, valueType );
// clearing anamolies along the axes
if ( xp == 0 && yp == 0 )
{
pixelValue /= 4;
}
else if ( xp == 0 || yp == 0 )
{
pixelValue /= 2;
}
int pos[4];
pos[0] = ( myBuffer + xp ) * blockSize + ( myBuffer + yp );
pos[1] = ( myBuffer + xp ) * blockSize + ( myBuffer - yp );
pos[2] = ( myBuffer - xp ) * blockSize + ( myBuffer + yp );
pos[3] = ( myBuffer - xp ) * blockSize + ( myBuffer - yp );
for ( int p = 0; p < 4; p++ )
{
if ( dataBuffer[ pos[p] ] == NO_DATA )
{
dataBuffer[ pos[p] ] = 0;
}
dataBuffer[ pos[p] ] += pixelValue;
}
}
}
if ( GDALRasterIO( poBand, GF_Write, xPosition, yPosition, blockSize, blockSize,
dataBuffer, blockSize, blockSize, GDT_Float32, 0, 0 ) != CE_None )
{
QgsDebugMsg( "Raster IO Error" );
}
CPLFree( dataBuffer );
}
}
// Finally close the dataset
GDALClose(( GDALDatasetH ) heatmapDS );
// Open the file in QGIS window if requested
if ( d.addToCanvas() )
{
mQGisIface->addRasterLayer( d.outputFilename(), QFileInfo( d.outputFilename() ).baseName() );
}
}
bool DEM::load(const std::string& filename) {
GDALAllRegister();
GDALDataset* poDS;
poDS = (GDALDataset*)GDALOpenEx(filename.c_str(), GDAL_OF_RASTER, NULL, NULL, NULL);
if (poDS == NULL) return false;
double adfGeoTransform[6];
if (poDS->GetGeoTransform(adfGeoTransform) == CE_None) {
origin.x = adfGeoTransform[0];
origin.y = adfGeoTransform[3];
pixelSize.x = adfGeoTransform[1];
pixelSize.y = abs(adfGeoTransform[5]);
}
width = poDS->GetRasterXSize() * pixelSize.x;
height = poDS->GetRasterYSize() * pixelSize.y;
data.resize(width * height);
min_val = std::numeric_limits<float>::max();
max_val = -std::numeric_limits<float>::max();
// bandが存在しない場合は、エラー
if (poDS->GetRasterCount() == 0) return false;
// 最初のbandのみを読み込む。複数bandは未対応
GDALRasterBand* poBand = poDS->GetRasterBand(1);
int nBlockXSize, nBlockYSize;
poBand->GetBlockSize(&nBlockXSize, &nBlockYSize);
//printf("Block=%dx%d Type=%s, ColorInterp=%s\n", nBlockXSize, nBlockYSize, GDALGetDataTypeName(poBand->GetRasterDataType()), GDALGetColorInterpretationName(poBand->GetColorInterpretation()));
// 最低、最高の値を取得
int bGotMin, bGotMax;
double adfMinMax[2];
adfMinMax[0] = poBand->GetMinimum(&bGotMin);
adfMinMax[1] = poBand->GetMaximum(&bGotMax);
if (!(bGotMin && bGotMax)) GDALComputeRasterMinMax((GDALRasterBandH)poBand, TRUE, adfMinMax);
//printf("Min=%.3fd, Max=%.3f\n", adfMinMax[0], adfMinMax[1]);
min_val = adfMinMax[0];
max_val = adfMinMax[1];
//int nXSize = poBand->GetXSize();
//int nYSize = poBand->GetYSize();
int nXBlocks = (poBand->GetXSize() + nBlockXSize - 1) / nBlockXSize;
int nYBlocks = (poBand->GetYSize() + nBlockYSize - 1) / nBlockYSize;
float *pData = (float *)CPLMalloc(sizeof(float*) * nBlockXSize * nBlockYSize);
for (int iYBlock = 0; iYBlock < nYBlocks; iYBlock++) {
for (int iXBlock = 0; iXBlock < nXBlocks; iXBlock++) {
int nXValid, nYValid;
poBand->ReadBlock(iXBlock, iYBlock, pData);
// Compute the portion of the block that is valid
// for partial edge blocks.
if ((iXBlock + 1) * nBlockXSize > poBand->GetXSize())
nXValid = poBand->GetXSize() - iXBlock * nBlockXSize;
else
nXValid = nBlockXSize;
if ((iYBlock + 1) * nBlockYSize > poBand->GetYSize())
nYValid = poBand->GetYSize() - iYBlock * nBlockYSize;
else
nYValid = nBlockYSize;
for (int iY = 0; iY < nYValid; iY++) {
for (int iX = 0; iX < nXValid; iX++) {
float val;
if (pData[iY * nBlockXSize + iX] > max_val) {
val = max_val;
}
else if (pData[iY * nBlockXSize + iX] < min_val) {
val = min_val;
}
else {
val = pData[iY * nBlockXSize + iX];
}
for (int y = 0; y < pixelSize.y; ++y) {
for (int x = 0; x < pixelSize.x; ++x) {
data[((iYBlock * nBlockYSize + iY) * pixelSize.y + y) * width + (iXBlock * nBlockXSize + iX) * pixelSize.x + x] = val;
}
}
}
}
}
}
GDALClose(poDS);
return true;
}
CC_FILE_ERROR RasterGridFilter::loadFile(const char* filename, ccHObject& container, bool alwaysDisplayLoadDialog/*=true*/, bool* coordinatesShiftEnabled/*=0*/, CCVector3d* coordinatesShift/*=0*/)
{
GDALAllRegister();
ccLog::PrintDebug("(GDAL drivers: %i)", GetGDALDriverManager()->GetDriverCount());
GDALDataset* poDataset = static_cast<GDALDataset*>(GDALOpen( filename, GA_ReadOnly ));
if( poDataset != NULL )
{
ccLog::Print("Raster file: '%s'", filename);
ccLog::Print( "Driver: %s/%s",
poDataset->GetDriver()->GetDescription(),
poDataset->GetDriver()->GetMetadataItem( GDAL_DMD_LONGNAME ) );
int rasterCount = poDataset->GetRasterCount();
int rasterX = poDataset->GetRasterXSize();
int rasterY = poDataset->GetRasterYSize();
ccLog::Print( "Size is %dx%dx%d", rasterX, rasterY, rasterCount );
ccPointCloud* pc = new ccPointCloud();
if (!pc->reserve(static_cast<unsigned>(rasterX * rasterY)))
{
delete pc;
return CC_FERR_NOT_ENOUGH_MEMORY;
}
if( poDataset->GetProjectionRef() != NULL )
ccLog::Print( "Projection is `%s'", poDataset->GetProjectionRef() );
double adfGeoTransform[6] = { 0, //top left x
1, //w-e pixel resolution (can be negative)
0, //0
0, //top left y
0, //0
1 //n-s pixel resolution (can be negative)
};
if( poDataset->GetGeoTransform( adfGeoTransform ) == CE_None )
{
ccLog::Print( "Origin = (%.6f,%.6f)", adfGeoTransform[0], adfGeoTransform[3] );
ccLog::Print( "Pixel Size = (%.6f,%.6f)", adfGeoTransform[1], adfGeoTransform[5] );
}
if (adfGeoTransform[1] == 0 || adfGeoTransform[5] == 0)
{
ccLog::Warning("Invalid pixel size! Forcing it to (1,1)");
adfGeoTransform[1] = adfGeoTransform[5] = 1;
}
double origin[3] = { adfGeoTransform[0], adfGeoTransform[3], 0.0 };
CCVector3d Pshift(0,0,0);
//check for 'big' coordinates
{
bool shiftAlreadyEnabled = (coordinatesShiftEnabled && *coordinatesShiftEnabled && coordinatesShift);
if (shiftAlreadyEnabled)
Pshift = *coordinatesShift;
bool applyAll = false;
if (sizeof(PointCoordinateType) < 8 && ccCoordinatesShiftManager::Handle(origin,0,alwaysDisplayLoadDialog,shiftAlreadyEnabled,Pshift,0,applyAll))
{
pc->setGlobalShift(Pshift);
ccLog::Warning("[RasterFilter::loadFile] Raster has been recentered! Translation: (%.2f,%.2f,%.2f)",Pshift.x,Pshift.y,Pshift.z);
//we save coordinates shift information
if (applyAll && coordinatesShiftEnabled && coordinatesShift)
{
*coordinatesShiftEnabled = true;
*coordinatesShift = Pshift;
}
}
}
//create blank raster 'grid'
{
double z = 0.0 /*+ Pshift.z*/;
for (int j=0; j<rasterY; ++j)
{
double y = adfGeoTransform[3] + static_cast<double>(j) * adfGeoTransform[5] + Pshift.y;
CCVector3 P( 0,
static_cast<PointCoordinateType>(y),
static_cast<PointCoordinateType>(z));
for (int i=0; i<rasterX; ++i)
{
double x = adfGeoTransform[0] + static_cast<double>(i) * adfGeoTransform[1] + Pshift.x;
P.x = static_cast<PointCoordinateType>(x);
pc->addPoint(P);
}
}
QVariant xVar = QVariant::fromValue<int>(rasterX);
QVariant yVar = QVariant::fromValue<int>(rasterY);
pc->setMetaData("raster_width",xVar);
pc->setMetaData("raster_height",yVar);
}
//fetch raster bands
bool zRasterProcessed = false;
unsigned zInvalid = 0;
double zMinMax[2] = {0, 0};
for (int i=1; i<=rasterCount; ++i)
{
ccLog::Print( "Reading band #%i", i);
GDALRasterBand* poBand = poDataset->GetRasterBand(i);
GDALColorInterp colorInterp = poBand->GetColorInterpretation();
GDALDataType bandType = poBand->GetRasterDataType();
int nBlockXSize, nBlockYSize;
poBand->GetBlockSize( &nBlockXSize, &nBlockYSize );
ccLog::Print( "Block=%dx%d Type=%s, ColorInterp=%s", nBlockXSize, nBlockYSize, GDALGetDataTypeName(poBand->GetRasterDataType()), GDALGetColorInterpretationName(colorInterp) );
//fetching raster scan-line
int nXSize = poBand->GetXSize();
int nYSize = poBand->GetYSize();
assert(nXSize == rasterX);
assert(nYSize == rasterY);
int bGotMin, bGotMax;
double adfMinMax[2] = {0, 0};
adfMinMax[0] = poBand->GetMinimum( &bGotMin );
adfMinMax[1] = poBand->GetMaximum( &bGotMax );
if (!bGotMin || !bGotMax )
//DGM FIXME: if the file is corrupted (e.g. ASCII ArcGrid with missing rows) this method will enter in a infinite loop!
GDALComputeRasterMinMax((GDALRasterBandH)poBand, TRUE, adfMinMax);
ccLog::Print( "Min=%.3fd, Max=%.3f", adfMinMax[0], adfMinMax[1] );
GDALColorTable* colTable = poBand->GetColorTable();
if( colTable != NULL )
printf( "Band has a color table with %d entries", colTable->GetColorEntryCount() );
if( poBand->GetOverviewCount() > 0 )
printf( "Band has %d overviews", poBand->GetOverviewCount() );
if (colorInterp == GCI_Undefined && !zRasterProcessed/*&& !colTable*/) //probably heights?
{
zRasterProcessed = true;
zMinMax[0] = adfMinMax[0];
zMinMax[1] = adfMinMax[1];
double* scanline = (double*) CPLMalloc(sizeof(double)*nXSize);
//double* scanline = new double[nXSize];
memset(scanline,0,sizeof(double)*nXSize);
for (int j=0; j<nYSize; ++j)
{
if (poBand->RasterIO( GF_Read, /*xOffset=*/0, /*yOffset=*/j, /*xSize=*/nXSize, /*ySize=*/1, /*buffer=*/scanline, /*bufferSizeX=*/nXSize, /*bufferSizeY=*/1, /*bufferType=*/GDT_Float64, /*x_offset=*/0, /*y_offset=*/0 ) != CE_None)
{
delete pc;
CPLFree(scanline);
GDALClose(poDataset);
return CC_FERR_READING;
}
for (int k=0; k<nXSize; ++k)
{
double z = static_cast<double>(scanline[k]) + Pshift[2];
unsigned pointIndex = static_cast<unsigned>(k + j * rasterX);
if (pointIndex <= pc->size())
{
if (z < zMinMax[0] || z > zMinMax[1])
{
z = zMinMax[0] - 1.0;
++zInvalid;
}
const_cast<CCVector3*>(pc->getPoint(pointIndex))->z = static_cast<PointCoordinateType>(z);
}
}
}
//update bounding-box
pc->invalidateBoundingBox();
if (scanline)
CPLFree(scanline);
scanline = 0;
}
else //colors
{
bool isRGB = false;
bool isScalar = false;
bool isPalette = false;
switch(colorInterp)
{
case GCI_Undefined:
isScalar = true;
break;
case GCI_PaletteIndex:
isPalette = true;
break;
case GCI_RedBand:
case GCI_GreenBand:
case GCI_BlueBand:
isRGB = true;
break;
case GCI_AlphaBand:
if (adfMinMax[0] != adfMinMax[1])
isScalar = true;
else
ccLog::Warning(QString("Alpha band ignored as it has a unique value (%1)").arg(adfMinMax[0]));
break;
default:
isScalar = true;
break;
}
if (isRGB || isPalette)
{
//first check that a palette exists if the band is a palette index
if (isPalette && !colTable)
{
ccLog::Warning(QString("Band is declared as a '%1' but no palette is associated!").arg(GDALGetColorInterpretationName(colorInterp)));
isPalette = false;
}
else
{
//instantiate memory for RBG colors if necessary
if (!pc->hasColors() && !pc->setRGBColor(MAX_COLOR_COMP,MAX_COLOR_COMP,MAX_COLOR_COMP))
{
ccLog::Warning(QString("Failed to instantiate memory for storing color band '%1'!").arg(GDALGetColorInterpretationName(colorInterp)));
}
else
{
assert(bandType <= GDT_Int32);
int* colIndexes = (int*) CPLMalloc(sizeof(int)*nXSize);
//double* scanline = new double[nXSize];
memset(colIndexes,0,sizeof(int)*nXSize);
for (int j=0; j<nYSize; ++j)
{
if (poBand->RasterIO( GF_Read, /*xOffset=*/0, /*yOffset=*/j, /*xSize=*/nXSize, /*ySize=*/1, /*buffer=*/colIndexes, /*bufferSizeX=*/nXSize, /*bufferSizeY=*/1, /*bufferType=*/GDT_Int32, /*x_offset=*/0, /*y_offset=*/0 ) != CE_None)
{
CPLFree(colIndexes);
delete pc;
return CC_FERR_READING;
}
for (int k=0; k<nXSize; ++k)
{
unsigned pointIndex = static_cast<unsigned>(k + j * rasterX);
if (pointIndex <= pc->size())
{
colorType* C = const_cast<colorType*>(pc->getPointColor(pointIndex));
switch(colorInterp)
{
case GCI_PaletteIndex:
assert(colTable);
{
GDALColorEntry col;
colTable->GetColorEntryAsRGB(colIndexes[k],&col);
C[0] = static_cast<colorType>(col.c1 & MAX_COLOR_COMP);
C[1] = static_cast<colorType>(col.c2 & MAX_COLOR_COMP);
C[2] = static_cast<colorType>(col.c3 & MAX_COLOR_COMP);
}
break;
case GCI_RedBand:
C[0] = static_cast<colorType>(colIndexes[k] & MAX_COLOR_COMP);
break;
case GCI_GreenBand:
C[1] = static_cast<colorType>(colIndexes[k] & MAX_COLOR_COMP);
break;
case GCI_BlueBand:
C[2] = static_cast<colorType>(colIndexes[k] & MAX_COLOR_COMP);
break;
default:
assert(false);
break;
}
}
}
}
if (colIndexes)
CPLFree(colIndexes);
colIndexes = 0;
pc->showColors(true);
}
}
}
else if (isScalar)
{
ccScalarField* sf = new ccScalarField(GDALGetColorInterpretationName(colorInterp));
if (!sf->resize(pc->size(),true,NAN_VALUE))
{
ccLog::Warning(QString("Failed to instantiate memory for storing '%1' as a scalar field!").arg(sf->getName()));
sf->release();
sf = 0;
}
else
{
double* colValues = (double*) CPLMalloc(sizeof(double)*nXSize);
//double* scanline = new double[nXSize];
memset(colValues,0,sizeof(double)*nXSize);
for (int j=0; j<nYSize; ++j)
{
if (poBand->RasterIO( GF_Read, /*xOffset=*/0, /*yOffset=*/j, /*xSize=*/nXSize, /*ySize=*/1, /*buffer=*/colValues, /*bufferSizeX=*/nXSize, /*bufferSizeY=*/1, /*bufferType=*/GDT_Float64, /*x_offset=*/0, /*y_offset=*/0 ) != CE_None)
{
CPLFree(colValues);
delete pc;
return CC_FERR_READING;
}
for (int k=0; k<nXSize; ++k)
{
unsigned pointIndex = static_cast<unsigned>(k + j * rasterX);
if (pointIndex <= pc->size())
{
ScalarType s = static_cast<ScalarType>(colValues[k]);
sf->setValue(pointIndex,s);
}
}
}
if (colValues)
CPLFree(colValues);
colValues = 0;
sf->computeMinAndMax();
pc->addScalarField(sf);
if (pc->getNumberOfScalarFields() == 1)
pc->setCurrentDisplayedScalarField(0);
pc->showSF(true);
}
}
}
}
if (pc)
{
if (!zRasterProcessed)
{
ccLog::Warning("Raster has no height (Z) information: you can convert one of its scalar fields to Z with 'Edit > Scalar Fields > Set SF as coordinate(s)'");
}
else if (zInvalid != 0 && zInvalid < pc->size())
{
//shall we remove the points with invalid heights?
if (QMessageBox::question(0,"Remove NaN points?","This raster has pixels with invalid heights. Shall we remove them?",QMessageBox::Yes, QMessageBox::No) == QMessageBox::Yes)
{
CCLib::ReferenceCloud validPoints(pc);
unsigned count = pc->size();
bool error = true;
if (validPoints.reserve(count-zInvalid))
{
for (unsigned i=0; i<count; ++i)
{
if (pc->getPoint(i)->z >= zMinMax[0])
validPoints.addPointIndex(i);
}
if (validPoints.size() > 0)
{
validPoints.resize(validPoints.size());
ccPointCloud* newPC = pc->partialClone(&validPoints);
if (newPC)
{
delete pc;
pc = newPC;
error = false;
}
}
else
{
assert(false);
}
}
if (error)
{
ccLog::Error("Not enough memory to remove the points with invalid heights!");
}
}
}
container.addChild(pc);
}
GDALClose(poDataset);
}
else
{
return CC_FERR_UNKNOWN_FILE;
}
return CC_FERR_NO_ERROR;
}
bool Shape::load(const std::string& filename) {
GDALAllRegister();
GDALDataset* poDS;
poDS = (GDALDataset*)GDALOpenEx(filename.c_str(), GDAL_OF_VECTOR, NULL, NULL, NULL);
if (poDS == NULL) return false;
// 初期化
shapeObjects.clear();
minBound.x = std::numeric_limits<float>::max();
minBound.y = std::numeric_limits<float>::max();
minBound.z = std::numeric_limits<float>::max();
maxBound.x = -std::numeric_limits<float>::max();
maxBound.y = -std::numeric_limits<float>::max();
maxBound.z = -std::numeric_limits<float>::max();
int nLayers = poDS->GetLayerCount();
int i = 0;
for (int n = 0; n < nLayers; ++n) {
OGRLayer* poLayer = poDS->GetLayer(n);
shapeType = poLayer->GetGeomType();
shapeObjects.resize(shapeObjects.size() + poLayer->GetFeatureCount());
OGRFeature* poFeature;
poLayer->ResetReading();
while ((poFeature = poLayer->GetNextFeature()) != NULL) {
// 属性の名前を読み込む
std::vector<std::string> fieldNames;
for (int j = 0; j < poFeature->GetFieldCount(); ++j) {
OGRFieldDefn* poFieldDefn = poFeature->GetFieldDefnRef(j);
fieldNames.push_back(poFieldDefn->GetNameRef());
}
// 属性の値を読み込む
OGRFeatureDefn *poFDefn = poLayer->GetLayerDefn();
for (int j = 0; j < poFDefn->GetFieldCount(); ++j) {
OGRFieldDefn* poFieldDefn = poFDefn->GetFieldDefn(j);
if (poFieldDefn->GetType() == OFTInteger) {
shapeObjects[i].attributes[fieldNames[j]] = Variant(poFeature->GetFieldAsInteger(j));
}
else if (poFieldDefn->GetType() == OFTInteger64) {
shapeObjects[i].attributes[fieldNames[j]] = Variant(poFeature->GetFieldAsInteger(j));
}
else if (poFieldDefn->GetType() == OFTReal) {
shapeObjects[i].attributes[fieldNames[j]] = Variant(poFeature->GetFieldAsDouble(j));
}
else if (poFieldDefn->GetType() == OFTString) {
shapeObjects[i].attributes[fieldNames[j]] = Variant(poFeature->GetFieldAsString(j));
}
else {
shapeObjects[i].attributes[fieldNames[j]] = Variant(poFeature->GetFieldAsString(j));
}
}
// このshapeのベクトルデータを読み込む
OGRGeometry* poGeometry = poFeature->GetGeometryRef();
if (poGeometry != NULL) {
if (wkbFlatten(poGeometry->getGeometryType()) == wkbPoint) {
shapeObjects[i].parts.resize(1);
shapeObjects[i].parts[0].points.resize(1);
OGRPoint* poPoint = (OGRPoint*)poGeometry;
shapeObjects[i].parts[0].points[0].x = poPoint->getX();
shapeObjects[i].parts[0].points[0].y = poPoint->getY();
updateBounds(poPoint);
}
else if (wkbFlatten(poGeometry->getGeometryType()) == wkbLineString) {
OGRLineString* poLineString = (OGRLineString*)poGeometry;
readLineString(poLineString, shapeObjects[i]);
}
else if (wkbFlatten(poGeometry->getGeometryType()) == wkbPolygon) {
OGRPolygon* poPolygon = (OGRPolygon*)poGeometry;
readPolygon(poPolygon, shapeObjects[i]);
}
else if (wkbFlatten(poGeometry->getGeometryType()) == wkbMultiPolygon) {
OGRMultiPolygon* poMultiPolygon = (OGRMultiPolygon*)poGeometry;
readMultiPolygon(poMultiPolygon, shapeObjects[i]);
}
else {
// not supported
}
}
// shapeObjectsのインデックスをインクリメント
i++;
// OGRが取得したメモリを開放
OGRFeature::DestroyFeature(poFeature);
}
}
GDALClose(poDS);
return true;
}
int main(int argc, char **argv)
{
GDALAllRegister();
try
{
boost::timer::cpu_timer timer;
input_arguments parsed_args;
boost::program_options::options_description options_all("Fire Points to SciDB's Multidimensional Array Conversion Options");
options_all.add_options()
("version", "Print Fire Points to SciDB conversion tool version.\n")
("help", "Prints help message.\n")
("verbose", "Turns on verbose mode: prints timing and some more information about the conversion progress.\n")
("f", boost::program_options::value<std::string>(&parsed_args.source_file_name), "The source TIFF file to convert to SciDB's load format.\n")
("o", boost::program_options::value<std::string>(&parsed_args.target_file_name), "The target folder to store SciDB data file.\n")
("t", boost::program_options::value<int16_t>(&parsed_args.time_point), "The timeline position for the dataset.\n")
;
boost::program_options::variables_map options;
boost::program_options::store(boost::program_options::parse_command_line(argc, argv, options_all), options);
boost::program_options::notify(options);
if(options.count("help"))
{
std::cout << options_all << std::endl;
return EXIT_SUCCESS;
}
if(options.count("version"))
{
std::cout << "\n\nfocos2scidb version: " SCIETL_VERSION_STRING "\n" << std::endl;
return EXIT_SUCCESS;
}
parsed_args.verbose = options.count("verbose") ? true : false;
valid_args(parsed_args);
if(parsed_args.verbose)
std::cout << "\nfocos2scidb started\n" << std::endl;
convert(parsed_args);
if(parsed_args.verbose)
std::cout << "\n\nfocos2scidb finished successfully!\n" << std::endl;
}
catch(const std::exception& e)
{
std::cerr << "\n\nfocos2scidb finished with errors!\n";
if(e.what() != 0)
std::cerr << "\nAn unexpected error has occurried: " << e.what() << "\n";
std::cerr << "\nPlease, report it to [email protected].\n" << std::endl;
return EXIT_FAILURE;
}
catch(...)
{
std::cerr << "\n\nAn unexpected error has occurried with no additional information.\n" << std::endl;
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int main( int argc, char ** argv )
{
/* -------------------------------------------------------------------- */
/* Process arguments. */
/* -------------------------------------------------------------------- */
argc = GDALGeneralCmdLineProcessor(argc, &argv, 0);
if( argc < 1 )
exit(-argc);
int nThreadCount = 4;
bool bOpenInThreads = true;
for( int iArg = 1; iArg < argc; iArg++ )
{
if( iArg < argc-1 && EQUAL(argv[iArg], "-i") )
{
nIterations = atoi(argv[++iArg]);
}
else if( iArg < argc-1 && EQUAL(argv[iArg], "-oi") )
{
nOpenIterations = atoi(argv[++iArg]);
}
else if( iArg < argc-1 && EQUAL(argv[iArg], "-t") )
{
nThreadCount = atoi(argv[++iArg]);
}
else if( EQUAL(argv[iArg], "-lock_on_open") )
{
bLockOnOpen = true;
}
else if( EQUAL(argv[iArg], "-open_in_main") )
{
bOpenInThreads = false;
}
else if( pszFilename == nullptr )
{
pszFilename = argv[iArg];
}
else
{
printf("Unrecognized argument: %s\n", argv[iArg]);
Usage();
}
}
if( pszFilename == nullptr )
{
printf("Need a file to operate on.\n");
Usage();
exit(1);
}
if( nOpenIterations > 0 )
bLockOnOpen = false;
/* -------------------------------------------------------------------- */
/* Get the checksum of band1. */
/* -------------------------------------------------------------------- */
GDALDatasetH hDS = nullptr;
GDALAllRegister();
for( int i = 0; i < 2; i++ )
{
hDS = GDALOpen( pszFilename, GA_ReadOnly );
if( hDS == nullptr )
exit( 1 );
nChecksum = GDALChecksumImage(GDALGetRasterBand(hDS, 1),
0, 0,
GDALGetRasterXSize(hDS),
GDALGetRasterYSize(hDS));
GDALClose(hDS);
}
printf(
"Got checksum %d, launching %d worker threads on %s, %d iterations.\n",
nChecksum, nThreadCount, pszFilename, nIterations);
/* -------------------------------------------------------------------- */
/* Fire off worker threads. */
/* -------------------------------------------------------------------- */
pGlobalMutex = CPLCreateMutex();
CPLReleaseMutex(pGlobalMutex);
nPendingThreads = nThreadCount;
std::vector<GDALDatasetH> aoDS;
for( int iThread = 0; iThread < nThreadCount; iThread++ )
{
hDS = nullptr;
if( !bOpenInThreads )
{
hDS = GDALOpen(pszFilename, GA_ReadOnly);
if( !hDS )
{
printf("GDALOpen() failed.\n");
exit(1);
}
aoDS.push_back(hDS);
}
if( CPLCreateThread(WorkerFunc, hDS) == -1 )
{
printf("CPLCreateThread() failed.\n");
exit(1);
}
}
while( nPendingThreads > 0 )
CPLSleep(0.5);
CPLDestroyMutex(pGlobalMutex);
for( size_t i = 0; i < aoDS.size(); ++i )
GDALClose(aoDS[i]);
printf("All threads complete.\n");
CSLDestroy(argv);
GDALDestroyDriverManager();
return 0;
}
int main(int argc, char *argv[])
{
const char *index_filename = NULL;
const char *tile_index = "location";
int i_arg, ti_field;
OGRDataSourceH hTileIndexDS;
OGRLayerH hLayer = NULL;
OGRFeatureDefnH hFDefn;
int write_absolute_path = FALSE;
char* current_path = NULL;
int i;
int nExistingFiles;
int skip_different_projection = FALSE;
char** existingFilesTab = NULL;
int alreadyExistingProjectionRefValid = FALSE;
char* alreadyExistingProjectionRef = NULL;
char* index_filename_mod;
int bExists;
VSIStatBuf sStatBuf;
const char *pszTargetSRS = "";
int bSetTargetSRS = FALSE;
OGRSpatialReferenceH hTargetSRS = NULL;
/* Check that we are running against at least GDAL 1.4 */
/* Note to developers : if we use newer API, please change the requirement */
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1400)
{
fprintf(stderr, "At least, GDAL >= 1.4.0 is required for this version of %s, "
"which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME);
exit(1);
}
GDALAllRegister();
OGRRegisterAll();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Get commandline arguments other than the GDAL raster filenames. */
/* -------------------------------------------------------------------- */
for( i_arg = 1; i_arg < argc; i_arg++ )
{
if( EQUAL(argv[i_arg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(argv[i_arg],"--help") )
Usage(NULL);
else if( strcmp(argv[i_arg],"-tileindex") == 0 )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
tile_index = argv[++i_arg];
}
else if( strcmp(argv[i_arg],"-t_srs") == 0 )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszTargetSRS = argv[++i_arg];
bSetTargetSRS = TRUE;
}
else if ( strcmp(argv[i_arg],"-write_absolute_path") == 0 )
{
write_absolute_path = TRUE;
}
else if ( strcmp(argv[i_arg],"-skip_different_projection") == 0 )
{
skip_different_projection = TRUE;
}
else if( argv[i_arg][0] == '-' )
Usage(CPLSPrintf("Unkown option name '%s'", argv[i_arg]));
else if( index_filename == NULL )
{
index_filename = argv[i_arg];
i_arg++;
break;
}
}
if( index_filename == NULL )
Usage("No index filename specified.");
if( i_arg == argc )
Usage("No file to index specified.");
/* -------------------------------------------------------------------- */
/* Create and validate target SRS if given. */
/* -------------------------------------------------------------------- */
if( bSetTargetSRS )
{
if ( skip_different_projection )
{
fprintf( stderr,
"Warning : -skip_different_projection does not apply "
"when -t_srs is requested.\n" );
}
hTargetSRS = OSRNewSpatialReference("");
if( OSRSetFromUserInput( hTargetSRS, pszTargetSRS ) != CE_None )
{
OSRDestroySpatialReference( hTargetSRS );
fprintf( stderr, "Invalid target SRS `%s'.\n",
pszTargetSRS );
exit(1);
}
}
/* -------------------------------------------------------------------- */
/* Open or create the target shapefile and DBF file. */
/* -------------------------------------------------------------------- */
index_filename_mod = CPLStrdup(CPLResetExtension(index_filename, "shp"));
bExists = (VSIStat(index_filename_mod, &sStatBuf) == 0);
if (!bExists)
{
CPLFree(index_filename_mod);
index_filename_mod = CPLStrdup(CPLResetExtension(index_filename, "SHP"));
bExists = (VSIStat(index_filename_mod, &sStatBuf) == 0);
}
CPLFree(index_filename_mod);
if (bExists)
{
hTileIndexDS = OGROpen( index_filename, TRUE, NULL );
if (hTileIndexDS != NULL)
{
hLayer = OGR_DS_GetLayer(hTileIndexDS, 0);
}
}
else
{
OGRSFDriverH hDriver;
const char* pszDriverName = "ESRI Shapefile";
printf( "Creating new index file...\n" );
hDriver = OGRGetDriverByName( pszDriverName );
if( hDriver == NULL )
{
printf( "%s driver not available.\n", pszDriverName );
exit( 1 );
}
hTileIndexDS = OGR_Dr_CreateDataSource( hDriver, index_filename, NULL );
if (hTileIndexDS)
{
char* pszLayerName = CPLStrdup(CPLGetBasename(index_filename));
/* get spatial reference for output file from target SRS (if set) */
/* or from first input file */
OGRSpatialReferenceH hSpatialRef = NULL;
if( bSetTargetSRS )
{
hSpatialRef = OSRClone( hTargetSRS );
}
else
{
GDALDatasetH hDS = GDALOpen( argv[i_arg], GA_ReadOnly );
if (hDS)
{
const char* pszWKT = GDALGetProjectionRef(hDS);
if (pszWKT != NULL && pszWKT[0] != '\0')
{
hSpatialRef = OSRNewSpatialReference(pszWKT);
}
GDALClose(hDS);
}
}
hLayer = OGR_DS_CreateLayer( hTileIndexDS, pszLayerName, hSpatialRef, wkbPolygon, NULL );
CPLFree(pszLayerName);
if (hSpatialRef)
OSRRelease(hSpatialRef);
if (hLayer)
{
OGRFieldDefnH hFieldDefn = OGR_Fld_Create( tile_index, OFTString );
OGR_Fld_SetWidth( hFieldDefn, 255);
OGR_L_CreateField( hLayer, hFieldDefn, TRUE );
OGR_Fld_Destroy(hFieldDefn);
}
}
}
if( hTileIndexDS == NULL || hLayer == NULL )
{
fprintf( stderr, "Unable to open/create shapefile `%s'.\n",
index_filename );
exit(2);
}
hFDefn = OGR_L_GetLayerDefn(hLayer);
for( ti_field = 0; ti_field < OGR_FD_GetFieldCount(hFDefn); ti_field++ )
{
OGRFieldDefnH hFieldDefn = OGR_FD_GetFieldDefn( hFDefn, ti_field );
if( strcmp(OGR_Fld_GetNameRef(hFieldDefn), tile_index) == 0 )
break;
}
if( ti_field == OGR_FD_GetFieldCount(hFDefn) )
{
fprintf( stderr, "Unable to find field `%s' in DBF file `%s'.\n",
tile_index, index_filename );
exit(2);
}
/* Load in memory existing file names in SHP */
nExistingFiles = OGR_L_GetFeatureCount(hLayer, FALSE);
if (nExistingFiles)
{
OGRFeatureH hFeature;
existingFilesTab = (char**)CPLMalloc(nExistingFiles * sizeof(char*));
for(i=0;i<nExistingFiles;i++)
{
hFeature = OGR_L_GetNextFeature(hLayer);
existingFilesTab[i] = CPLStrdup(OGR_F_GetFieldAsString( hFeature, ti_field ));
if (i == 0)
{
GDALDatasetH hDS = GDALOpen(existingFilesTab[i], GA_ReadOnly );
if (hDS)
{
alreadyExistingProjectionRefValid = TRUE;
alreadyExistingProjectionRef = CPLStrdup(GDALGetProjectionRef(hDS));
GDALClose(hDS);
}
}
OGR_F_Destroy( hFeature );
}
}
if (write_absolute_path)
{
current_path = CPLGetCurrentDir();
if (current_path == NULL)
{
fprintf( stderr, "This system does not support the CPLGetCurrentDir call. "
"The option -write_absolute_path will have no effect\n");
write_absolute_path = FALSE;
}
}
/* -------------------------------------------------------------------- */
/* loop over GDAL files, processing. */
/* -------------------------------------------------------------------- */
for( ; i_arg < argc; i_arg++ )
{
GDALDatasetH hDS;
double adfGeoTransform[6];
double adfX[5], adfY[5];
int nXSize, nYSize;
char* fileNameToWrite;
const char* projectionRef;
VSIStatBuf sStatBuf;
int k;
OGRFeatureH hFeature;
OGRGeometryH hPoly, hRing;
/* Make sure it is a file before building absolute path name */
if (write_absolute_path && CPLIsFilenameRelative( argv[i_arg] ) &&
VSIStat( argv[i_arg], &sStatBuf ) == 0)
{
fileNameToWrite = CPLStrdup(CPLProjectRelativeFilename(current_path, argv[i_arg]));
}
else
{
fileNameToWrite = CPLStrdup(argv[i_arg]);
}
/* Checks that file is not already in tileindex */
for(i=0;i<nExistingFiles;i++)
{
if (EQUAL(fileNameToWrite, existingFilesTab[i]))
{
fprintf(stderr, "File %s is already in tileindex. Skipping it.\n",
fileNameToWrite);
break;
}
}
if (i != nExistingFiles)
{
CPLFree(fileNameToWrite);
continue;
}
hDS = GDALOpen( argv[i_arg], GA_ReadOnly );
if( hDS == NULL )
{
fprintf( stderr, "Unable to open %s, skipping.\n",
argv[i_arg] );
CPLFree(fileNameToWrite);
continue;
}
GDALGetGeoTransform( hDS, adfGeoTransform );
if( adfGeoTransform[0] == 0.0
&& adfGeoTransform[1] == 1.0
&& adfGeoTransform[3] == 0.0
&& ABS(adfGeoTransform[5]) == 1.0 )
{
fprintf( stderr,
"It appears no georeferencing is available for\n"
"`%s', skipping.\n",
argv[i_arg] );
GDALClose( hDS );
CPLFree(fileNameToWrite);
continue;
}
projectionRef = GDALGetProjectionRef(hDS);
/* if not set target srs, test that the current file uses same projection as others */
if( !bSetTargetSRS )
{
if (alreadyExistingProjectionRefValid)
{
int projectionRefNotNull, alreadyExistingProjectionRefNotNull;
projectionRefNotNull = projectionRef && projectionRef[0];
alreadyExistingProjectionRefNotNull = alreadyExistingProjectionRef && alreadyExistingProjectionRef[0];
if ((projectionRefNotNull &&
alreadyExistingProjectionRefNotNull &&
EQUAL(projectionRef, alreadyExistingProjectionRef) == 0) ||
(projectionRefNotNull != alreadyExistingProjectionRefNotNull))
{
fprintf(stderr, "Warning : %s is not using the same projection system as "
"other files in the tileindex.\n"
"This may cause problems when using it in MapServer for example.\n"
"Use -t_srs option to set target projection system (not supported by MapServer).\n"
"%s\n", argv[i_arg],
(skip_different_projection) ? "Skipping this file." : "");
if (skip_different_projection)
{
CPLFree(fileNameToWrite);
GDALClose( hDS );
continue;
}
}
}
else
{
alreadyExistingProjectionRefValid = TRUE;
alreadyExistingProjectionRef = CPLStrdup(projectionRef);
}
}
nXSize = GDALGetRasterXSize( hDS );
nYSize = GDALGetRasterYSize( hDS );
adfX[0] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[0] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
adfX[1] = adfGeoTransform[0]
+ nXSize * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[1] = adfGeoTransform[3]
+ nXSize * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
adfX[2] = adfGeoTransform[0]
+ nXSize * adfGeoTransform[1]
+ nYSize * adfGeoTransform[2];
adfY[2] = adfGeoTransform[3]
+ nXSize * adfGeoTransform[4]
+ nYSize * adfGeoTransform[5];
adfX[3] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ nYSize * adfGeoTransform[2];
adfY[3] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ nYSize * adfGeoTransform[5];
adfX[4] = adfGeoTransform[0]
+ 0 * adfGeoTransform[1]
+ 0 * adfGeoTransform[2];
adfY[4] = adfGeoTransform[3]
+ 0 * adfGeoTransform[4]
+ 0 * adfGeoTransform[5];
/* if set target srs, do the forward transformation of all points */
if( bSetTargetSRS )
{
OGRSpatialReferenceH hSourceSRS = NULL;
OGRCoordinateTransformationH hCT = NULL;
hSourceSRS = OSRNewSpatialReference( projectionRef );
if( hSourceSRS && !OSRIsSame( hSourceSRS, hTargetSRS ) )
{
hCT = OCTNewCoordinateTransformation( hSourceSRS, hTargetSRS );
if( hCT == NULL || !OCTTransform( hCT, 5, adfX, adfY, NULL ) )
{
fprintf( stderr,
"Warning : unable to transform points from source SRS `%s' to target SRS `%s'\n"
"for file `%s' - file skipped\n",
projectionRef, pszTargetSRS, fileNameToWrite );
if ( hCT )
OCTDestroyCoordinateTransformation( hCT );
if ( hSourceSRS )
OSRDestroySpatialReference( hSourceSRS );
continue;
}
if ( hCT )
OCTDestroyCoordinateTransformation( hCT );
}
if ( hSourceSRS )
OSRDestroySpatialReference( hSourceSRS );
}
hFeature = OGR_F_Create( OGR_L_GetLayerDefn( hLayer ) );
OGR_F_SetFieldString( hFeature, ti_field, fileNameToWrite );
hPoly = OGR_G_CreateGeometry(wkbPolygon);
hRing = OGR_G_CreateGeometry(wkbLinearRing);
for(k=0;k<5;k++)
OGR_G_SetPoint_2D(hRing, k, adfX[k], adfY[k]);
OGR_G_AddGeometryDirectly( hPoly, hRing );
OGR_F_SetGeometryDirectly( hFeature, hPoly );
if( OGR_L_CreateFeature( hLayer, hFeature ) != OGRERR_NONE )
{
printf( "Failed to create feature in shapefile.\n" );
break;
}
OGR_F_Destroy( hFeature );
CPLFree(fileNameToWrite);
GDALClose( hDS );
}
CPLFree(current_path);
if (nExistingFiles)
{
for(i=0;i<nExistingFiles;i++)
{
CPLFree(existingFilesTab[i]);
}
CPLFree(existingFilesTab);
}
CPLFree(alreadyExistingProjectionRef);
if ( hTargetSRS )
OSRDestroySpatialReference( hTargetSRS );
OGR_DS_Destroy( hTileIndexDS );
GDALDestroyDriverManager();
OGRCleanupAll();
CSLDestroy(argv);
exit( 0 );
}
int main(int argc, const char** argv) {
/// Parse input arguments
InputArgs* input_args = InputArgs::Init(argc, argv);
if (nullptr == input_args) { exit(EXIT_FAILURE); }
/// Register GDAL
GDALAllRegister();
/// Initialize of MPI environment
int numprocs;
int world_rank;
int name_len;
char processor_name[MPI_MAX_PROCESSOR_NAME];
MPI_Init(NULL, NULL);
{
MPI_Comm_size(MCW, &numprocs);
MPI_Comm_rank(MCW, &world_rank);
MPI_Get_processor_name(processor_name, &name_len);
MPI_Group MPI_GROUP_WORLD, slave_group;
MPI_Comm slave_comm;
MPI_Comm_group(MCW, &MPI_GROUP_WORLD);
// create the master, transfer and calculation groups
static int not_slave_ranks[] = {MASTER_RANK};
// create slaveGroup which exclude the master rank (i.e., notSlaveRanks)
MPI_Group_excl(MPI_GROUP_WORLD, 1, not_slave_ranks, &slave_group);
MPI_Comm_create(MCW, slave_group, &slave_comm);
if (numprocs < 2) {
cout << "The number of processors must be greater than 1!" << endl;
MPI_Abort(MCW, 1);
}
int nslaves = numprocs - 1;
try {
if (world_rank == MASTER_RANK) {
/// connect to mongodb, abort if failed.
MongoClient* mclient = MongoClient::Init(input_args->host.c_str(), input_args->port);
if (nullptr == mclient) {
cout << "Connect to MongoDB (" << input_args->host
<< ":" << input_args->port << ") failed!" << endl;
MPI_Abort(MCW, 2);
}
// read river topology data
map<int, SubbasinStruct *> subbasin_map;
set<int> group_set;
string group_method = REACH_KMETIS; // by default
if (CreateReachTopology(mclient, input_args->model_name, group_method,
nslaves, subbasin_map, group_set) != 0) {
cout << "Read and create reaches topology information failed." << endl;
MPI_Abort(MCW, 1);
}
delete mclient;
if (size_t(nslaves) != group_set.size()) {
group_set.clear();
cout << "The number of slave processes (" << nslaves << ") is not consist with the group number("
<< group_set.size() << ")." << endl;
MPI_Abort(MCW, 1);
}
// Run management process on master rank
MasterProcess(subbasin_map, group_set);
// Release memory
for (auto it = subbasin_map.begin(); it != subbasin_map.end();) {
delete it->second;
subbasin_map.erase(it++);
}
} else {
// Run computing process on slave ranks
CalculateProcess(world_rank, numprocs, nslaves, slave_comm, input_args);
}
MPI_Barrier(MCW);
// free MPI sources
MPI_Group_free(&MPI_GROUP_WORLD);
MPI_Group_free(&slave_group);
// VS2013: Fatal error in MPI_Comm_free: Invalid communicator, error stack.
// I still think the communicator should be released. by lj.
// MPI_Comm_free(&slaveComm);
} catch (ModelException& e) {
cout << e.what() << endl;
MPI_Abort(MCW, 3);
}
catch (std::exception& e) {
cout << e.what() << endl;
MPI_Abort(MCW, 4);
}
catch (...) {
cout << "Unknown exception occurred!" << endl;
MPI_Abort(MCW, 5);
}
}
/// clean up
delete input_args;
/// Finalize the MPI environment and exit with success
MPI_Finalize();
return 0;
}
int main( int argc, char ** argv )
{
/* Check strict compilation and runtime library version as we use C++ API */
if( ! GDAL_CHECK_VERSION(argv[0]) )
exit(1);
EarlySetConfigOptions(argc, argv);
/* -------------------------------------------------------------------- */
/* Register standard GDAL drivers, and process generic GDAL */
/* command options. */
/* -------------------------------------------------------------------- */
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 2 )
{
Usage("Not enough arguments.");
}
if( EQUAL(argv[1], "--utility_version") ||
EQUAL(argv[1], "--utility-version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
CSLDestroy( argv );
return 0;
}
else if( EQUAL(argv[1],"--help") )
Usage();
GDALDEMProcessingOptionsForBinary* psOptionsForBinary =
GDALDEMProcessingOptionsForBinaryNew();
GDALDEMProcessingOptions *psOptions =
GDALDEMProcessingOptionsNew(argv + 1, psOptionsForBinary);
CSLDestroy( argv );
if( psOptions == NULL )
{
Usage();
}
if( !(psOptionsForBinary->bQuiet) )
{
GDALDEMProcessingOptionsSetProgress(psOptions, GDALTermProgress, NULL);
}
if( psOptionsForBinary->pszSrcFilename == NULL )
{
Usage("Missing source.");
}
if ( EQUAL(psOptionsForBinary->pszProcessing, "color-relief") &&
psOptionsForBinary->pszColorFilename == NULL )
{
Usage("Missing color file.");
}
if( psOptionsForBinary->pszDstFilename == NULL )
{
Usage("Missing destination.");
}
if( !psOptionsForBinary->bQuiet &&
!psOptionsForBinary->bFormatExplicitlySet)
{
CheckExtensionConsistency(psOptionsForBinary->pszDstFilename,
psOptionsForBinary->pszFormat);
}
// Open Dataset and get raster band.
GDALDatasetH hSrcDataset =
GDALOpen( psOptionsForBinary->pszSrcFilename, GA_ReadOnly );
if( hSrcDataset == NULL )
{
fprintf( stderr,
"GDALOpen failed - %d\n%s\n",
CPLGetLastErrorNo(), CPLGetLastErrorMsg() );
GDALDestroyDriverManager();
exit( 1 );
}
int bUsageError = FALSE;
GDALDatasetH hOutDS =
GDALDEMProcessing(psOptionsForBinary->pszDstFilename, hSrcDataset,
psOptionsForBinary->pszProcessing,
psOptionsForBinary->pszColorFilename,
psOptions, &bUsageError);
if( bUsageError )
Usage();
const int nRetCode = hOutDS ? 0 : 1;
GDALClose(hSrcDataset);
GDALClose(hOutDS);
GDALDEMProcessingOptionsFree(psOptions);
GDALDEMProcessingOptionsForBinaryFree(psOptionsForBinary);
GDALDestroyDriverManager();
return nRetCode;
}
int main(int /* argc*/ , char* /* argv */[])
{
int nOvrLevel;
int nBandNum;
GDALDatasetH hDS;
GDALDatasetH hSrcDS;
FILE* f;
const char* pszGDAL_SKIP = CPLGetConfigOption("GDAL_SKIP", NULL);
if( pszGDAL_SKIP == NULL )
CPLSetConfigOption("GDAL_SKIP", "GIF");
else
CPLSetConfigOption("GDAL_SKIP", CPLSPrintf("%s GIF", pszGDAL_SKIP));
GDALAllRegister();
hDS = GDALOpen("../gcore/data/byte.tif", GA_ReadOnly);
if (hDS)
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
hDS = GDALOpen("../gcore/data/byte.vrt", GA_ReadOnly);
if (hDS)
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
hDS = GDALOpen("../gdrivers/data/rgb_warp.vrt", GA_ReadOnly);
if (hDS)
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
hDS = GDALOpen("../gdrivers/data/A.TOC", GA_ReadOnly);
hDS = GDALOpen("NITF_TOC_ENTRY:CADRG_ONC_1,000,000_2_0:../gdrivers/data/A.TOC", GA_ReadOnly);
if (hDS)
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
hDS = GDALOpen("../gdrivers/data/testtil.til", GA_ReadOnly);
if (hDS)
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
hDS = GDALOpen("../gdrivers/data/product.xml", GA_ReadOnly);
if (hDS)
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
hDS = GDALOpen("../gdrivers/data/METADATA.DIM", GA_ReadOnly);
if (hDS)
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
hDS = GDALOpen("../gdrivers/tmp/cache/file9_j2c.ntf", GA_ReadOnly);
if (hDS)
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
hDS = GDALOpen("../gdrivers/data/bug407.gif", GA_ReadOnly);
if (hDS)
{
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
GDALSetCacheMax(0);
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
}
/* Create external overviews */
hSrcDS = GDALOpen("../gcore/data/byte.tif", GA_ReadOnly);
hDS = GDALCreateCopy(GDALGetDriverByName("GTiff"), "byte.tif", hSrcDS, 0, NULL, NULL, NULL);
GDALClose(hSrcDS);
hSrcDS = NULL;
hDS = GDALOpen("byte.tif", GA_ReadOnly);
nOvrLevel = 2;
nBandNum = 1;
GDALBuildOverviews( hDS, "NEAR", 1, &nOvrLevel, 1, &nBandNum, NULL, NULL);
GDALClose(hDS);
hDS = GDALOpen("byte.tif", GA_ReadOnly);
GDALGetOverviewCount(GDALGetRasterBand(hDS, 1));
/* Create internal overviews */
hSrcDS = GDALOpen("../gcore/data/byte.tif", GA_ReadOnly);
hDS = GDALCreateCopy(GDALGetDriverByName("GTiff"), "byte2.tif", hSrcDS, 0, NULL, NULL, NULL);
GDALClose(hSrcDS);
hSrcDS = NULL;
hDS = GDALOpen("byte2.tif", GA_Update);
nOvrLevel = 2;
nBandNum = 1;
GDALBuildOverviews( hDS, "NEAR", 1, &nOvrLevel, 1, &nBandNum, NULL, NULL);
GDALClose(hDS);
hDS = GDALOpen("byte2.tif", GA_ReadOnly);
GDALGetOverviewCount(GDALGetRasterBand(hDS, 1));
/* Create external mask */
hSrcDS = GDALOpen("../gcore/data/byte.tif", GA_ReadOnly);
hDS = GDALCreateCopy(GDALGetDriverByName("GTiff"), "byte3.tif", hSrcDS, 0, NULL, NULL, NULL);
GDALClose(hSrcDS);
hSrcDS = NULL;
hDS = GDALOpen("byte3.tif", GA_ReadOnly);
GDALCreateDatasetMaskBand(hDS, GMF_PER_DATASET);
GDALClose(hDS);
hDS = GDALOpen("byte3.tif", GA_ReadOnly);
GDALGetMaskFlags(GDALGetRasterBand(hDS, 1));
f = fopen("byte.vrt", "wb");
fprintf(f, "%s", "<VRTDataset rasterXSize=\"20\" rasterYSize=\"20\">"
"<VRTRasterBand dataType=\"Byte\" band=\"1\">"
"<SimpleSource>"
"<SourceFilename relativeToVRT=\"1\">../gcore/data/byte.tif</SourceFilename>"
"<SourceBand>1</SourceBand>"
"<SourceProperties RasterXSize=\"20\" RasterYSize=\"20\" DataType=\"Byte\" BlockXSize=\"20\" BlockYSize=\"20\" />"
"<SrcRect xOff=\"0\" yOff=\"0\" xSize=\"20\" ySize=\"20\"/>"
"<DstRect xOff=\"0\" yOff=\"0\" xSize=\"20\" ySize=\"20\"/>"
"</SimpleSource>"
"</VRTRasterBand>"
"</VRTDataset>");
fclose(f);
hDS = GDALOpen("byte.vrt", GA_ReadOnly);
nOvrLevel = 2;
nBandNum = 1;
GDALBuildOverviews( hDS, "NEAR", 1, &nOvrLevel, 1, &nBandNum, NULL, NULL);
GDALClose(hDS);
hDS = GDALOpen("byte.vrt", GA_ReadOnly);
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
GDALGetOverviewCount(GDALGetRasterBand(hDS, 1));
hDS = GDALOpen("<VRTDataset rasterXSize=\"20\" rasterYSize=\"20\">"
"<VRTRasterBand dataType=\"Byte\" band=\"1\">"
"<SimpleSource>"
"<SourceFilename relativeToVRT=\"1\">byte.vrt</SourceFilename>"
"<SourceBand>1</SourceBand>"
"<SourceProperties RasterXSize=\"20\" RasterYSize=\"20\" DataType=\"Byte\" BlockXSize=\"20\" BlockYSize=\"20\" />"
"<SrcRect xOff=\"0\" yOff=\"0\" xSize=\"20\" ySize=\"20\"/>"
"<DstRect xOff=\"0\" yOff=\"0\" xSize=\"20\" ySize=\"20\"/>"
"</SimpleSource>"
"</VRTRasterBand>"
"</VRTDataset>", GA_ReadOnly);
GDALChecksumImage(GDALGetRasterBand(hDS, 1), 0, 0, GDALGetRasterXSize(hDS), GDALGetRasterYSize(hDS));
hDS = GDALOpenShared("../gcore/data/byte.tif", GA_ReadOnly);
hDS = GDALOpenShared("../gcore/data/byte.tif", GA_ReadOnly);
hDS = GDALOpenShared("../gdrivers/data/mercator.sid", GA_ReadOnly);
hDS = GDALOpen("RASTERLITE:../gdrivers/data/rasterlite_pyramids.sqlite,table=test", GA_ReadOnly);
hDS = GDALOpen("RASTERLITE:../gdrivers/data/rasterlite_pyramids.sqlite,table=test,level=1", GA_ReadOnly);
OpenJPEG2000("../gdrivers/data/rgbwcmyk01_YeGeo_kakadu.jp2");
hDS = GDALOpen("../gdrivers/tmp/cache/Europe 2001_OZF.map", GA_ReadOnly);
CPLDebug("TEST","Call GDALDestroyDriverManager()");
GDALDestroyDriverManager();
unlink("byte.tif");
unlink("byte.tif.ovr");
unlink("byte2.tif");
unlink("byte3.tif");
unlink("byte3.tif.msk");
unlink("byte.vrt");
return 0;
}
int main( int nArgc, char ** papszArgv )
{
GDALDatasetH hDataset;
const char *pszResampling = "nearest";
const char *pszFilename = NULL;
int anLevels[1024];
int nLevelCount = 0;
int nResultStatus = 0;
int bReadOnly = FALSE;
int bClean = FALSE;
GDALProgressFunc pfnProgress = GDALTermProgress;
int *panBandList = NULL;
int nBandCount = 0;
char **papszOpenOptions = NULL;
/* Check that we are running against at least GDAL 1.7 */
/* Note to developers : if we use newer API, please change the requirement */
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1700)
{
fprintf(stderr, "At least, GDAL >= 1.7.0 is required for this version of %s, "
"which was compiled against GDAL %s\n", papszArgv[0], GDAL_RELEASE_NAME);
exit(1);
}
GDALAllRegister();
nArgc = GDALGeneralCmdLineProcessor( nArgc, &papszArgv, 0 );
if( nArgc < 1 )
exit( -nArgc );
/* -------------------------------------------------------------------- */
/* Parse commandline. */
/* -------------------------------------------------------------------- */
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(papszArgv[iArg],"--help") )
Usage();
else if( EQUAL(papszArgv[iArg],"-r") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszResampling = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-ro"))
bReadOnly = TRUE;
else if( EQUAL(papszArgv[iArg],"-clean"))
bClean = TRUE;
else if( EQUAL(papszArgv[iArg],"-q") || EQUAL(papszArgv[iArg],"-quiet") )
pfnProgress = GDALDummyProgress;
else if( EQUAL(papszArgv[iArg],"-b"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
const char* pszBand = papszArgv[iArg+1];
int nBand = atoi(pszBand);
if( nBand < 1 )
{
printf( "Unrecognizable band number (%s).\n", papszArgv[iArg+1] );
Usage();
GDALDestroyDriverManager();
exit( 2 );
}
iArg++;
nBandCount++;
panBandList = (int *)
CPLRealloc(panBandList, sizeof(int) * nBandCount);
panBandList[nBandCount-1] = nBand;
}
else if( EQUAL(papszArgv[iArg], "-oo") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszOpenOptions = CSLAddString( papszOpenOptions,
papszArgv[++iArg] );
}
else if( papszArgv[iArg][0] == '-' )
Usage(CPLSPrintf("Unknown option name '%s'", papszArgv[iArg]));
else if( pszFilename == NULL )
pszFilename = papszArgv[iArg];
else if( atoi(papszArgv[iArg]) > 0 )
{
anLevels[nLevelCount++] = atoi(papszArgv[iArg]);
if( anLevels[nLevelCount-1] == 1 )
{
printf("Warning: Overview with subsampling factor of 1 requested. This will copy the full resolution dataset in the overview !\n");
}
}
else
Usage("Too many command options.");
}
if( pszFilename == NULL )
Usage("No datasource specified.");
if( nLevelCount == 0 && !bClean )
Usage("No overview level specified.");
/* -------------------------------------------------------------------- */
/* Open data file. */
/* -------------------------------------------------------------------- */
if (bReadOnly)
hDataset = NULL;
else
{
CPLPushErrorHandler( CPLQuietErrorHandler );
hDataset = GDALOpenEx( pszFilename, GDAL_OF_RASTER | GDAL_OF_UPDATE, NULL, papszOpenOptions, NULL );
CPLPopErrorHandler();
}
if( hDataset == NULL )
hDataset = GDALOpenEx( pszFilename, GDAL_OF_RASTER, NULL, papszOpenOptions, NULL );
CSLDestroy(papszOpenOptions);
papszOpenOptions = NULL;
if( hDataset == NULL )
exit( 2 );
/* -------------------------------------------------------------------- */
/* Clean overviews. */
/* -------------------------------------------------------------------- */
if ( bClean &&
GDALBuildOverviews( hDataset,pszResampling, 0, 0,
0, NULL, pfnProgress, NULL ) != CE_None )
{
printf( "Cleaning overviews failed.\n" );
nResultStatus = 200;
}
/* -------------------------------------------------------------------- */
/* Generate overviews. */
/* -------------------------------------------------------------------- */
//Only HFA support selected layers
if(nBandCount > 0)
CPLSetConfigOption( "USE_RRD", "YES" );
if (nLevelCount > 0 && nResultStatus == 0 &&
GDALBuildOverviews( hDataset,pszResampling, nLevelCount, anLevels,
nBandCount, panBandList, pfnProgress, NULL ) != CE_None )
{
printf( "Overview building failed.\n" );
nResultStatus = 100;
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
GDALClose(hDataset);
CSLDestroy( papszArgv );
CPLFree(panBandList);
GDALDestroyDriverManager();
return nResultStatus;
}
int main(int c, char *v[])
{
// process input arguments
if (c < 2) {
print_help(v);
return 1;
}
// optional arguments
const char *output_file = pick_option(&c, &v, "o", "stdout");
bool binary = (bool) pick_option(&c, &v, "b", NULL);
bool verbose = (bool) pick_option(&c, &v, "-verbose", NULL);
int max_nb_pts = atoi(pick_option(&c, &v, "-max-nb-pts", "INT_MAX"));
float thresh_dog = atof(pick_option(&c, &v, "-thresh-dog", "0.0133"));
int ss_noct = atoi(pick_option(&c, &v, "-scale-space-noct", "8"));
int ss_nspo = atoi(pick_option(&c, &v, "-scale-space-nspo", "3"));
// initialise time
struct timespec ts; portable_gettime(&ts);
// define the rectangular region of interest (roi)
int x, y, w, h;
if (c == 2) {
x = 0;
y = 0;
} else if (c == 6) {
x = atoi(v[2]);
y = atoi(v[3]);
w = atoi(v[4]);
h = atoi(v[5]);
} else {
print_help(v);
return 1;
}
// read the roi in the input image
GDALDatasetH hDataset;
GDALAllRegister();
hDataset = GDALOpen( v[1], GA_ReadOnly );
if( hDataset == NULL )
{
fprintf(stderr, "ERROR : can't open %s\n", v[1]);
}
GDALRasterBandH hBand;
hBand = GDALGetRasterBand( hDataset, 1 );
float *roi;
roi = (float *) CPLMalloc(sizeof(float)*w*h);
GDALRasterIO( hBand, GF_Read, x, y, w, h,
roi, w, h, GDT_Float32,
0, 0 );
GDALClose(hBand);
GDALClose(hDataset);
if (verbose) print_elapsed_time(&ts, "read ROI", 35);
// prepare sift parameters
struct sift_parameters* p = sift_assign_default_parameters();
p->C_DoG = thresh_dog;
p->n_oct = ss_noct;
p->n_spo = ss_nspo;
// compute sift keypoints
struct sift_scalespace **ss = (struct sift_scalespace**) malloc(4 * sizeof(struct sift_scalespace*));
struct sift_keypoints **kk = (struct sift_keypoints**) malloc(6 * sizeof(struct sift_keypoints*));
for (int i = 0; i < 6; i++)
kk[i] = sift_malloc_keypoints();
struct sift_keypoints* kpts = sift_anatomy(roi, w, h, p, ss, kk);
if (verbose) print_elapsed_time(&ts, "run SIFT", 35);
// add (x, y) offset to keypoints coordinates
for (int i = 0; i < kpts->size; i++) {
kpts->list[i]->x += y; // in Ives' conventions x is the row index
kpts->list[i]->y += x;
}
if (verbose) print_elapsed_time(&ts, "add offset", 35);
// write to standard output
FILE *f = fopen(output_file, "w");
fprintf_keypoints(f, kpts, max_nb_pts, binary, 1);
fclose(f);
if (verbose) print_elapsed_time(&ts, "write output", 35);
// cleanup
CPLFree(roi);
sift_free_keypoints(kpts);
for (int i = 0; i < 6; i++)
sift_free_keypoints(kk[i]);
free(kk);
for (int i = 0; i < 4; i++)
sift_free_scalespace(ss[i]);
free(ss);
free(p);
return 0;
}