void QgsGDALGeorefTransform::destroy_gdal_args()
{
if ( mGDALTransformerArgs )
{
if ( mIsTPSTransform )
GDALDestroyTPSTransformer( mGDALTransformerArgs );
else
GDALDestroyGCPTransformer( mGDALTransformerArgs );
}
}
int main( int argc, char ** argv )
{
const char *pszSrcFilename = NULL;
const char *pszDstFilename = NULL;
int nOrder = 0;
void *hTransformArg;
GDALTransformerFunc pfnTransformer = NULL;
int nGCPCount = 0;
GDAL_GCP *pasGCPs = NULL;
int bInverse = FALSE;
char **papszTO = NULL;
/* Check that we are running against at least GDAL 1.5 */
/* Note to developers : if we use newer API, please change the requirement */
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1500)
{
fprintf(stderr, "At least, GDAL >= 1.5.0 is required for this version of %s, "
"which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME);
exit(1);
}
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
int i;
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],"-t_srs") && i < argc-1 )
{
char *pszSRS = SanitizeSRS(argv[++i]);
papszTO = CSLSetNameValue( papszTO, "DST_SRS", pszSRS );
CPLFree( pszSRS );
}
else if( EQUAL(argv[i],"-s_srs") && i < argc-1 )
{
char *pszSRS = SanitizeSRS(argv[++i]);
papszTO = CSLSetNameValue( papszTO, "SRC_SRS", pszSRS );
CPLFree( pszSRS );
}
else if( EQUAL(argv[i],"-order") && i < argc-1 )
{
nOrder = atoi(argv[++i]);
papszTO = CSLSetNameValue( papszTO, "MAX_GCP_ORDER", argv[i] );
}
else if( EQUAL(argv[i],"-tps") )
{
papszTO = CSLSetNameValue( papszTO, "METHOD", "GCP_TPS" );
nOrder = -1;
}
else if( EQUAL(argv[i],"-rpc") )
{
papszTO = CSLSetNameValue( papszTO, "METHOD", "RPC" );
}
else if( EQUAL(argv[i],"-geoloc") )
{
papszTO = CSLSetNameValue( papszTO, "METHOD", "GEOLOC_ARRAY" );
}
else if( EQUAL(argv[i],"-i") )
{
bInverse = TRUE;
}
else if( EQUAL(argv[i],"-to") && i < argc-1 )
{
papszTO = CSLAddString( papszTO, argv[++i] );
}
else if( EQUAL(argv[i],"-gcp") && i < argc - 4 )
{
char* endptr = NULL;
/* -gcp pixel line easting northing [elev] */
nGCPCount++;
pasGCPs = (GDAL_GCP *)
CPLRealloc( pasGCPs, sizeof(GDAL_GCP) * nGCPCount );
GDALInitGCPs( 1, pasGCPs + nGCPCount - 1 );
pasGCPs[nGCPCount-1].dfGCPPixel = atof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPLine = atof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPX = atof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPY = atof(argv[++i]);
if( argv[i+1] != NULL
&& (CPLStrtod(argv[i+1], &endptr) != 0.0 || argv[i+1][0] == '0') )
{
/* Check that last argument is really a number and not a filename */
/* looking like a number (see ticket #863) */
if (endptr && *endptr == 0)
pasGCPs[nGCPCount-1].dfGCPZ = atof(argv[++i]);
}
/* should set id and info? */
}
else if( argv[i][0] == '-' )
Usage();
else if( pszSrcFilename == NULL )
pszSrcFilename = argv[i];
else if( pszDstFilename == NULL )
pszDstFilename = argv[i];
else
Usage();
}
/* -------------------------------------------------------------------- */
/* Open src and destination file, if appropriate. */
/* -------------------------------------------------------------------- */
GDALDatasetH hSrcDS = NULL, hDstDS = NULL;
if( pszSrcFilename != NULL )
{
hSrcDS = GDALOpen( pszSrcFilename, GA_ReadOnly );
if( hSrcDS == NULL )
exit( 1 );
}
if( pszDstFilename != NULL )
{
hDstDS = GDALOpen( pszDstFilename, GA_ReadOnly );
if( hDstDS == NULL )
exit( 1 );
}
if( hSrcDS != NULL && nGCPCount > 0 )
{
fprintf( stderr, "Commandline GCPs and input file specified, specify one or the other.\n" );
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Create a transformation object from the source to */
/* destination coordinate system. */
/* -------------------------------------------------------------------- */
if( nGCPCount != 0 && nOrder == -1 )
{
pfnTransformer = GDALTPSTransform;
hTransformArg =
GDALCreateTPSTransformer( nGCPCount, pasGCPs, FALSE );
}
else if( nGCPCount != 0 )
{
pfnTransformer = GDALGCPTransform;
hTransformArg =
GDALCreateGCPTransformer( nGCPCount, pasGCPs, nOrder, FALSE );
}
else
{
pfnTransformer = GDALGenImgProjTransform;
hTransformArg =
GDALCreateGenImgProjTransformer2( hSrcDS, hDstDS, papszTO );
}
CSLDestroy( papszTO );
if( hTransformArg == NULL )
{
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Read points from stdin, transform and write to stdout. */
/* -------------------------------------------------------------------- */
while( !feof(stdin) )
{
char szLine[1024];
if( fgets( szLine, sizeof(szLine)-1, stdin ) == NULL )
break;
char **papszTokens = CSLTokenizeString(szLine);
double dfX, dfY, dfZ = 0.0;
int bSuccess = TRUE;
if( CSLCount(papszTokens) < 2 )
{
CSLDestroy(papszTokens);
continue;
}
dfX = atof(papszTokens[0]);
dfY = atof(papszTokens[1]);
if( CSLCount(papszTokens) >= 3 )
dfZ = atof(papszTokens[2]);
if( pfnTransformer( hTransformArg, bInverse, 1,
&dfX, &dfY, &dfZ, &bSuccess )
&& bSuccess )
{
printf( "%.15g %.15g %.15g\n", dfX, dfY, dfZ );
}
else
{
printf( "transformation failed.\n" );
}
CSLDestroy(papszTokens);
}
if( nGCPCount != 0 && nOrder == -1 )
{
GDALDestroyTPSTransformer(hTransformArg);
}
else if( nGCPCount != 0 )
{
GDALDestroyGCPTransformer(hTransformArg);
}
else
{
GDALDestroyGenImgProjTransformer(hTransformArg);
}
if (nGCPCount)
{
GDALDeinitGCPs( nGCPCount, pasGCPs );
CPLFree( pasGCPs );
}
if (hSrcDS)
GDALClose(hSrcDS);
if (hDstDS)
GDALClose(hDstDS);
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CSLDestroy( argv );
return 0;
}
void *GDALCreateTPSTransformerInt( int nGCPCount, const GDAL_GCP *pasGCPList,
int bReversed, char** papszOptions )
{
TPSTransformInfo *psInfo;
int iGCP;
/* -------------------------------------------------------------------- */
/* Allocate transform info. */
/* -------------------------------------------------------------------- */
psInfo = (TPSTransformInfo *) CPLCalloc(sizeof(TPSTransformInfo),1);
psInfo->pasGCPList = GDALDuplicateGCPs( nGCPCount, pasGCPList );
psInfo->nGCPCount = nGCPCount;
psInfo->bReversed = bReversed;
psInfo->poForward = new VizGeorefSpline2D( 2 );
psInfo->poReverse = new VizGeorefSpline2D( 2 );
strcpy( psInfo->sTI.szSignature, "GTI" );
psInfo->sTI.pszClassName = "GDALTPSTransformer";
psInfo->sTI.pfnTransform = GDALTPSTransform;
psInfo->sTI.pfnCleanup = GDALDestroyTPSTransformer;
psInfo->sTI.pfnSerialize = GDALSerializeTPSTransformer;
/* -------------------------------------------------------------------- */
/* Attach all the points to the transformation. */
/* -------------------------------------------------------------------- */
for( iGCP = 0; iGCP < nGCPCount; iGCP++ )
{
double afPL[2], afXY[2];
afPL[0] = pasGCPList[iGCP].dfGCPPixel;
afPL[1] = pasGCPList[iGCP].dfGCPLine;
afXY[0] = pasGCPList[iGCP].dfGCPX;
afXY[1] = pasGCPList[iGCP].dfGCPY;
if( bReversed )
{
psInfo->poReverse->add_point( afPL[0], afPL[1], afXY );
psInfo->poForward->add_point( afXY[0], afXY[1], afPL );
}
else
{
psInfo->poForward->add_point( afPL[0], afPL[1], afXY );
psInfo->poReverse->add_point( afXY[0], afXY[1], afPL );
}
}
psInfo->nRefCount = 1;
int nThreads = 1;
if( nGCPCount > 100 )
{
const char* pszWarpThreads = CSLFetchNameValue(papszOptions, "NUM_THREADS");
if (pszWarpThreads == NULL)
pszWarpThreads = CPLGetConfigOption("GDAL_NUM_THREADS", "1");
if (EQUAL(pszWarpThreads, "ALL_CPUS"))
nThreads = CPLGetNumCPUs();
else
nThreads = atoi(pszWarpThreads);
}
if( nThreads > 1 )
{
/* Compute direct and reverse transforms in parallel */
void* hThread = CPLCreateJoinableThread(GDALTPSComputeForwardInThread, psInfo);
psInfo->bReverseSolved = psInfo->poReverse->solve() != 0;
if( hThread != NULL )
CPLJoinThread(hThread);
else
psInfo->bForwardSolved = psInfo->poForward->solve() != 0;
}
else
{
psInfo->bForwardSolved = psInfo->poForward->solve() != 0;
psInfo->bReverseSolved = psInfo->poReverse->solve() != 0;
}
if( !psInfo->bForwardSolved || !psInfo->bReverseSolved )
{
GDALDestroyTPSTransformer(psInfo);
return NULL;
}
return psInfo;
}
MAIN_START(argc, argv)
{
// Check that we are running against at least GDAL 1.5.
// Note to developers: if we use newer API, please change the requirement.
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1500)
{
fprintf(stderr,
"At least, GDAL >= 1.5.0 is required for this version of %s, "
"which was compiled against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME);
exit(1);
}
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
const char *pszSrcFilename = nullptr;
const char *pszDstFilename = nullptr;
int nOrder = 0;
void *hTransformArg;
GDALTransformerFunc pfnTransformer = nullptr;
int nGCPCount = 0;
GDAL_GCP *pasGCPs = nullptr;
int bInverse = FALSE;
CPLStringList aosTO;
int bOutputXY = FALSE;
double dfX = 0.0;
double dfY = 0.0;
double dfZ = 0.0;
double dfT = 0.0;
bool bCoordOnCommandLine = false;
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
for( int i = 1; i < argc && argv[i] != nullptr; 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],"--help") )
{
Usage();
}
else if( EQUAL(argv[i],"-t_srs") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
const char *pszSRS = argv[++i];
if( !IsValidSRS(pszSRS) )
exit(1);
aosTO.SetNameValue("DST_SRS", pszSRS );
}
else if( EQUAL(argv[i],"-s_srs") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
const char *pszSRS = argv[++i];
if( !IsValidSRS(pszSRS) )
exit(1);
aosTO.SetNameValue("SRC_SRS", pszSRS );
}
else if( EQUAL(argv[i],"-ct") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
const char *pszCT = argv[++i];
aosTO.SetNameValue("COORDINATE_OPERATION", pszCT );
}
else if( EQUAL(argv[i],"-order") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
nOrder = atoi(argv[++i]);
aosTO.SetNameValue("MAX_GCP_ORDER", argv[i] );
}
else if( EQUAL(argv[i],"-tps") )
{
aosTO.SetNameValue("METHOD", "GCP_TPS" );
nOrder = -1;
}
else if( EQUAL(argv[i],"-rpc") )
{
aosTO.SetNameValue("METHOD", "RPC" );
}
else if( EQUAL(argv[i],"-geoloc") )
{
aosTO.SetNameValue("METHOD", "GEOLOC_ARRAY" );
}
else if( EQUAL(argv[i],"-i") )
{
bInverse = TRUE;
}
else if( EQUAL(argv[i],"-to") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
aosTO.AddString( argv[++i] );
}
else if( EQUAL(argv[i],"-gcp") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(4);
char* endptr = nullptr;
/* -gcp pixel line easting northing [elev] */
nGCPCount++;
pasGCPs = static_cast<GDAL_GCP *>(
CPLRealloc(pasGCPs, sizeof(GDAL_GCP) * nGCPCount));
GDALInitGCPs( 1, pasGCPs + nGCPCount - 1 );
pasGCPs[nGCPCount-1].dfGCPPixel = CPLAtof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPLine = CPLAtof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPX = CPLAtof(argv[++i]);
pasGCPs[nGCPCount-1].dfGCPY = CPLAtof(argv[++i]);
if( argv[i+1] != nullptr &&
(CPLStrtod(argv[i+1], &endptr) != 0.0 || argv[i+1][0] == '0') )
{
// Check that last argument is really a number and not a
// filename looking like a number (see ticket #863).
if (endptr && *endptr == 0)
pasGCPs[nGCPCount-1].dfGCPZ = CPLAtof(argv[++i]);
}
/* should set id and info? */
}
else if( EQUAL(argv[i],"-output_xy") )
{
bOutputXY = TRUE;
}
else if( EQUAL(argv[i],"-coord") && i + 2 < argc)
{
bCoordOnCommandLine = true;
dfX = CPLAtof(argv[++i]);
dfY = CPLAtof(argv[++i]);
if( i + 1 < argc && CPLGetValueType(argv[i+1]) != CPL_VALUE_STRING )
dfZ = CPLAtof(argv[++i]);
if( i + 1 < argc && CPLGetValueType(argv[i+1]) != CPL_VALUE_STRING )
dfT = CPLAtof(argv[++i]);
}
else if( argv[i][0] == '-' )
{
Usage(CPLSPrintf("Unknown option name '%s'", argv[i]));
}
else if( pszSrcFilename == nullptr )
{
pszSrcFilename = argv[i];
}
else if( pszDstFilename == nullptr )
{
pszDstFilename = argv[i];
}
else
{
Usage("Too many command options.");
}
}
/* -------------------------------------------------------------------- */
/* Open src and destination file, if appropriate. */
/* -------------------------------------------------------------------- */
GDALDatasetH hSrcDS = nullptr;
if( pszSrcFilename != nullptr )
{
hSrcDS = GDALOpen( pszSrcFilename, GA_ReadOnly );
if( hSrcDS == nullptr )
exit( 1 );
}
GDALDatasetH hDstDS = nullptr;
if( pszDstFilename != nullptr )
{
hDstDS = GDALOpen( pszDstFilename, GA_ReadOnly );
if( hDstDS == nullptr )
exit( 1 );
}
if( hSrcDS != nullptr && nGCPCount > 0 )
{
fprintf(stderr,
"Command line GCPs and input file specified, "
"specify one or the other.\n");
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Create a transformation object from the source to */
/* destination coordinate system. */
/* -------------------------------------------------------------------- */
if( nGCPCount != 0 && nOrder == -1 )
{
pfnTransformer = GDALTPSTransform;
hTransformArg =
GDALCreateTPSTransformer( nGCPCount, pasGCPs, FALSE );
}
else if( nGCPCount != 0 )
{
pfnTransformer = GDALGCPTransform;
hTransformArg =
GDALCreateGCPTransformer( nGCPCount, pasGCPs, nOrder, FALSE );
}
else
{
pfnTransformer = GDALGenImgProjTransform;
hTransformArg =
GDALCreateGenImgProjTransformer2( hSrcDS, hDstDS, aosTO.List() );
}
if( hTransformArg == nullptr )
{
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Read points from stdin, transform and write to stdout. */
/* -------------------------------------------------------------------- */
double dfLastT = 0.0;
while( bCoordOnCommandLine || !feof(stdin) )
{
if( !bCoordOnCommandLine )
{
char szLine[1024];
if( fgets( szLine, sizeof(szLine)-1, stdin ) == nullptr )
break;
char **papszTokens = CSLTokenizeString(szLine);
const int nCount = CSLCount(papszTokens);
if( nCount < 2 )
{
CSLDestroy(papszTokens);
continue;
}
dfX = CPLAtof(papszTokens[0]);
dfY = CPLAtof(papszTokens[1]);
if( nCount >= 3 )
dfZ = CPLAtof(papszTokens[2]);
else
dfZ = 0.0;
if( nCount == 4 )
dfT = CPLAtof(papszTokens[3]);
else
dfT = 0.0;
CSLDestroy(papszTokens);
}
if( dfT != dfLastT && nGCPCount == 0 )
{
if( dfT != 0.0 )
{
aosTO.SetNameValue("COORDINATE_EPOCH", CPLSPrintf("%g", dfT));
}
else
{
aosTO.SetNameValue("COORDINATE_EPOCH", nullptr);
}
GDALDestroyGenImgProjTransformer(hTransformArg);
hTransformArg =
GDALCreateGenImgProjTransformer2( hSrcDS, hDstDS, aosTO.List() );
}
int bSuccess = TRUE;
if( pfnTransformer( hTransformArg, bInverse, 1,
&dfX, &dfY, &dfZ, &bSuccess )
&& bSuccess )
{
if( bOutputXY )
CPLprintf( "%.15g %.15g\n", dfX, dfY );
else
CPLprintf( "%.15g %.15g %.15g\n", dfX, dfY, dfZ );
}
else
{
printf( "transformation failed.\n" );
}
if( bCoordOnCommandLine )
break;
dfLastT = dfT;
}
if( nGCPCount != 0 && nOrder == -1 )
{
GDALDestroyTPSTransformer(hTransformArg);
}
else if( nGCPCount != 0 )
{
GDALDestroyGCPTransformer(hTransformArg);
}
else
{
GDALDestroyGenImgProjTransformer(hTransformArg);
}
if (nGCPCount)
{
GDALDeinitGCPs( nGCPCount, pasGCPs );
CPLFree( pasGCPs );
}
if (hSrcDS)
GDALClose(hSrcDS);
if (hDstDS)
GDALClose(hDstDS);
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CSLDestroy( argv );
return 0;
}
/* Matlab Gateway routine */
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
char *pszSRS_WKT = NULL;
GDALDatasetH hSrcDS, hDstDS;
GDALDriverH hDriver;
GDALRasterBandH hBand;
OGRSpatialReference oSrcSRS, oDstSRS;
GDALResampleAlg interpMethod = GRA_NearestNeighbour;
GDALTransformerFunc pfnTransformer = NULL;
CPLErr eErr;
GDAL_GCP *pasGCPs = NULL;
void *hTransformArg;
static int runed_once = FALSE; /* It will be set to true if reaches end of main */
int nx, ny, i, j, m, n, c = 0, n_pts, n_fields;
char *pszSrcSRS = NULL, *pszSrcWKT = NULL;
char *pszDstSRS = NULL, *pszDstWKT = NULL;
double *in_data, *ptr_d, *x, *y, *z;
mxArray *mx_ptr;
int nGCPCount = 0, nOrder = 0;
char **papszMetadataOptions = NULL;
char *tmp, *txt;
int bInverse = FALSE;
int *bSuccess;
char **papszTO = NULL;
if (nrhs == 2 && mxIsStruct(prhs[1])) {
/* -------------------------------------------------- */
/* -------- 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, "inverse");
if (mx_ptr != NULL)
bInverse = TRUE;
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;
}
}
else {
mexPrintf("Usage: out = gdaltransform_mex(IN,PAR_STRUCT)\n\n");
mexPrintf(" IN is a Mx2 or Mx3 array of doubles with X, Y (,Z)\n");
mexPrintf(" PAR_STRUCT is a structure with at most two of the next fields:\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'inverse' reverse transformation. e.g from georef to rows-columns\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;
}
if (!runed_once) /* Do next call only at first time this MEX is loaded */
GDALAllRegister();
/* ----- Check that first argument contains at least a mx2 table */
n_pts = mxGetM (prhs[0]);
n_fields = mxGetN(prhs[0]);
if (!mxIsNumeric(prhs[0]) || (n_fields < 2)) {
mexPrintf("GDALTRANSFORM ERROR: first argument must contain a mx2 (or mx3) table\n");
mexErrMsgTxt(" with the x,y (,z) positions to convert.\n");
}
DEBUGA(1);
/* ---------- 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("GDALTRANSFORM: Translating source SRS failed.");
}
if (pszSrcWKT == NULL)
oSrcSRS.exportToWkt( &pszSrcWKT );
/* ------------------------------------------------------------------ */
DEBUGA(2);
/* ---------- 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("GDALTRANSFORM: Translating target SRS failed.");
}
if (pszDstWKT == NULL)
oDstSRS.exportToWkt( &pszDstWKT );
/* ------------------------------------------------------------------ */
/* -------------------------------------------------------------------- */
/* Create a transformation object from the source to */
/* destination coordinate system. */
/* -------------------------------------------------------------------- */
if( nGCPCount != 0 && nOrder == -1 ) {
pfnTransformer = GDALTPSTransform;
hTransformArg = GDALCreateTPSTransformer( nGCPCount, pasGCPs, FALSE );
}
else if( nGCPCount != 0 ) {
DEBUGA(3);
pfnTransformer = GDALGCPTransform;
hTransformArg = GDALCreateGCPTransformer( nGCPCount, pasGCPs, nOrder, FALSE );
}
else {
pfnTransformer = GDALGenImgProjTransform;
//hTransformArg = GDALCreateGenImgProjTransformer2( hSrcDS, hDstDS, papszTO );
hTransformArg =
GDALCreateGenImgProjTransformer( NULL, pszSrcWKT, NULL, pszDstWKT,
nGCPCount == 0 ? FALSE : TRUE, 0, nOrder );
}
//CSLDestroy( papszTO );
DEBUGA(4);
if( hTransformArg == NULL )
mexErrMsgTxt("GDALTRANSFORM: Generating transformer failed.");
in_data = (double *)mxGetData(prhs[0]);
if (n_pts == 1) {
x = &in_data[0];
y = &in_data[1];
bSuccess = &c;
}
else {
x = (double *)mxCalloc(n_pts, sizeof(double));
y = (double *)mxCalloc(n_pts, sizeof(double));
bSuccess = (int *)mxCalloc(n_pts, sizeof(int));
for (j = 0; j < n_pts; j++) {
x[j] = in_data[j];
y[j] = in_data[j+n_pts];
}
}
DEBUGA(5);
z = (double *)mxCalloc(n_pts, sizeof(double));
if (n_fields == 3)
for (j = 0; j < n_pts; j++)
z[j] = in_data[j+2*n_pts];
if ( !pfnTransformer( hTransformArg, bInverse, n_pts, x, y, z, bSuccess ) )
mexPrintf( "Transformation failed.\n" );
DEBUGA(6);
if( nGCPCount != 0 && nOrder == -1 )
GDALDestroyTPSTransformer(hTransformArg);
else if( nGCPCount != 0 )
GDALDestroyGCPTransformer(hTransformArg);
else
GDALDestroyGenImgProjTransformer(hTransformArg);
/* -------------- Copy the result into plhs --------------------------------- */
plhs[0] = mxCreateDoubleMatrix (n_pts,n_fields, mxREAL);
ptr_d = mxGetPr(plhs[0]);
for (j = 0; j < n_pts; j++) {
ptr_d[j] = x[j];
ptr_d[j+n_pts] = y[j];
}
if (n_pts > 1) {
mxFree((void *)x); mxFree((void *)y); mxFree((void *)bSuccess);
}
if (n_fields == 3) {
for (j = 0; j < n_pts; j++)
ptr_d[j+2*n_pts] = z[j];
}
mxFree((void *)z);
if (pszDstWKT && strlen(pszDstWKT) > 1 ) OGRFree(pszDstWKT);
if (pszSrcWKT && strlen(pszSrcWKT) > 1 ) OGRFree(pszSrcWKT);
//OGRFree(pszSrcWKT);
//OGRFree(pszDstWKT);
if (nGCPCount > 0) {
GDALDeinitGCPs( nGCPCount, pasGCPs ); // makes this mex crash in the next call
mxFree((void *) pasGCPs );
}
runed_once = TRUE; /* Signals that next call won't need to call GDALAllRegister() again */
}
void *GDALCreateTPSTransformerInt( int nGCPCount, const GDAL_GCP *pasGCPList,
int bReversed, char** papszOptions )
{
TPSTransformInfo *psInfo;
int iGCP;
/* -------------------------------------------------------------------- */
/* Allocate transform info. */
/* -------------------------------------------------------------------- */
psInfo = (TPSTransformInfo *) CPLCalloc(sizeof(TPSTransformInfo),1);
psInfo->pasGCPList = GDALDuplicateGCPs( nGCPCount, pasGCPList );
psInfo->nGCPCount = nGCPCount;
psInfo->bReversed = bReversed;
psInfo->poForward = new VizGeorefSpline2D( 2 );
psInfo->poReverse = new VizGeorefSpline2D( 2 );
memcpy( psInfo->sTI.abySignature, GDAL_GTI2_SIGNATURE, strlen(GDAL_GTI2_SIGNATURE) );
psInfo->sTI.pszClassName = "GDALTPSTransformer";
psInfo->sTI.pfnTransform = GDALTPSTransform;
psInfo->sTI.pfnCleanup = GDALDestroyTPSTransformer;
psInfo->sTI.pfnSerialize = GDALSerializeTPSTransformer;
psInfo->sTI.pfnCreateSimilar = GDALCreateSimilarTPSTransformer;
/* -------------------------------------------------------------------- */
/* Attach all the points to the transformation. */
/* -------------------------------------------------------------------- */
std::map< std::pair<double, double>, int > oMapPixelLineToIdx;
std::map< std::pair<double, double>, int > oMapXYToIdx;
for( iGCP = 0; iGCP < nGCPCount; iGCP++ )
{
double afPL[2], afXY[2];
afPL[0] = pasGCPList[iGCP].dfGCPPixel;
afPL[1] = pasGCPList[iGCP].dfGCPLine;
afXY[0] = pasGCPList[iGCP].dfGCPX;
afXY[1] = pasGCPList[iGCP].dfGCPY;
std::map< std::pair<double, double>, int >::iterator oIter;
oIter = oMapPixelLineToIdx.find( std::pair<double,double>(afPL[0], afPL[1]) );
if( oIter != oMapPixelLineToIdx.end() )
{
if( afXY[0] == pasGCPList[oIter->second].dfGCPX &&
afXY[1] == pasGCPList[oIter->second].dfGCPY )
{
continue;
}
else
{
CPLError(CE_Warning, CPLE_AppDefined,
"GCP %d and %d have same (pixel,line)=(%f,%f) but different (X,Y): (%f,%f) vs (%f,%f)",
iGCP + 1, oIter->second,
afPL[0], afPL[1],
afXY[0], afXY[1],
pasGCPList[oIter->second].dfGCPX, pasGCPList[oIter->second].dfGCPY);
}
}
else
{
oMapPixelLineToIdx[ std::pair<double,double>(afPL[0], afPL[1]) ] = iGCP;
}
oIter = oMapXYToIdx.find( std::pair<double,double>(afXY[0], afXY[1]) );
if( oIter != oMapXYToIdx.end() )
{
CPLError(CE_Warning, CPLE_AppDefined,
"GCP %d and %d have same (x,y)=(%f,%f) but different (pixel,line): (%f,%f) vs (%f,%f)",
iGCP + 1, oIter->second,
afXY[0], afXY[1],
afPL[0], afPL[1],
pasGCPList[oIter->second].dfGCPPixel, pasGCPList[oIter->second].dfGCPLine);
}
else
{
oMapXYToIdx[ std::pair<double,double>(afXY[0], afXY[1]) ] = iGCP;
}
bool bOK = true;
if( bReversed )
{
bOK &= psInfo->poReverse->add_point( afPL[0], afPL[1], afXY );
bOK &= psInfo->poForward->add_point( afXY[0], afXY[1], afPL );
}
else
{
bOK &= psInfo->poForward->add_point( afPL[0], afPL[1], afXY );
bOK &= psInfo->poReverse->add_point( afXY[0], afXY[1], afPL );
}
if( !bOK )
{
GDALDestroyTPSTransformer(psInfo);
return NULL;
}
}
psInfo->nRefCount = 1;
int nThreads = 1;
if( nGCPCount > 100 )
{
const char* pszWarpThreads = CSLFetchNameValue(papszOptions, "NUM_THREADS");
if (pszWarpThreads == NULL)
pszWarpThreads = CPLGetConfigOption("GDAL_NUM_THREADS", "1");
if (EQUAL(pszWarpThreads, "ALL_CPUS"))
nThreads = CPLGetNumCPUs();
else
nThreads = atoi(pszWarpThreads);
}
if( nThreads > 1 )
{
/* Compute direct and reverse transforms in parallel */
CPLJoinableThread* hThread = CPLCreateJoinableThread(GDALTPSComputeForwardInThread, psInfo);
psInfo->bReverseSolved = psInfo->poReverse->solve() != 0;
if( hThread != NULL )
CPLJoinThread(hThread);
else
psInfo->bForwardSolved = psInfo->poForward->solve() != 0;
}
else
{
psInfo->bForwardSolved = psInfo->poForward->solve() != 0;
psInfo->bReverseSolved = psInfo->poReverse->solve() != 0;
}
if( !psInfo->bForwardSolved || !psInfo->bReverseSolved )
{
GDALDestroyTPSTransformer(psInfo);
return NULL;
}
return psInfo;
}
