// reproject shape
shape_t*
shape_proj(
const shape_t* shape,
const char* from,
const char* to ){
shape_t* projected = shape_copy(shape);
projPJ old_prj = pj_init_plus(from);
projPJ new_prj = pj_init_plus(to);
for(uint32_t i=0; i<kv_size(projected->points); i++) {
point_t* p = &kv_A(projected->points, i);
p->x *= DEG_TO_RAD;
p->y *= DEG_TO_RAD;
int32_t err = pj_transform(old_prj, new_prj, 1, 0, &p->x, &p->y, NULL);
if (err)
fprintf(stderr, "ERR%d %s\n", err, pj_strerrno(err));
assert(err == 0);
}
for(uint32_t i=0; i<kv_size(projected->hull); i++) {
point_t* p = &kv_A(projected->hull, i);
p->x *= DEG_TO_RAD;
p->y *= DEG_TO_RAD;
int32_t err = pj_transform(old_prj, new_prj, 1, 0, &p->x, &p->y, NULL);
if (err)
fprintf(stderr, "ERR%d %s\n", err, pj_strerrno(err));
assert(err == 0);
}
pj_free(old_prj);
pj_free(new_prj);
return projected;
}
bool CMapDEM::getOrigRegion(QVector<qint16>& data,projXY &topLeft, projXY &bottomRight, int& w, int& h)
{
//memset(data, 0, sizeof(qint16) * h * w);
data.fill(0);
if(pjsrc == 0) return false;
// 1. convert top left and bottom right point into the projection system used by the DEM data
pj_transform(pjtar, pjsrc, 1, 0, &topLeft.u, &topLeft.v, 0);
pj_transform(pjtar, pjsrc, 1, 0, &bottomRight.u, &bottomRight.v, 0);
// 2. get floating point offset of topleft corner
double xoff1_f = (topLeft.u - xref1) / xscale;
double yoff1_f = (topLeft.v - yref1) / yscale;
// 3. truncate floating point offset into integer offset
int xoff1 = floor(xoff1_f); //qDebug() << "xoff1:" << xoff1 << xoff1_f;
int yoff1 = floor(yoff1_f); //qDebug() << "yoff1:" << yoff1 << yoff1_f;
// 4. get floating point offset of bottom right corner
double xoff2_f = (bottomRight.u - xref1) / xscale;
double yoff2_f = (bottomRight.v - yref1) / yscale;
// 5. truncate floating point offset into integer offset.
int xoff2 = ceil(xoff2_f); //qDebug() << "xoff2:" << xoff2 << xoff2_f;
int yoff2 = ceil(yoff2_f); //qDebug() << "yoff2:" << yoff2 << yoff2_f;
// 6. get width and height to read from file
qint32 w1 = xoff2 - xoff1 + 1;
//qDebug() << "w1:" << w1 << "h1:" << h1;
qint32 h1 = yoff2 - yoff1 + 1;
topLeft.u = xoff1 * xscale + xref1;
topLeft.v = yoff1 * yscale + yref1;
bottomRight.u = xoff2 * xscale + xref1;
bottomRight.v = yoff2 * yscale + yref1;
pj_transform(pjsrc, pjtar, 1, 0, &topLeft.u, &topLeft.v, 0);
pj_transform(pjsrc, pjtar, 1, 0, &bottomRight.u, &bottomRight.v, 0);
// memory sanity check
if(double(w1) * double(h1) > pow(2.0f,31)) return false;
if (w1 < w)
{
w = w1;
}
if (h1 < h)
{
h = h1;
}
Q_ASSERT(w1 <= w);
Q_ASSERT(h1 <= h);
// 7. read DEM data from file
CPLErr err = dataset->RasterIO(GF_Read, xoff1, yoff1, w1, h1, data.data(), w, h, GDT_Int16, 1, 0, 0, 0, 0);
return (err != CE_Failure);
}
int main(){
// char *pr1[] = {"+proj=latlong", "+ellps=WGS84"};
char *pr1[] = {"+proj=tmerc", "+ellps=WGS84", "+lon_0=39",
"+scale=1", "+lat_0=0", "+x_0=500000"};
char *pr2[] = {"+proj=tmerc", "+ellps=krass", "+lon_0=39",
"+scale=1", "+lat_0=0", "+x_0=500000"};
projPJ P1 = pj_init(6, pr1);
projPJ P2 = pj_init(6, pr2);
if (!P1) {
fprintf(stderr, "can't create projection 1\n");
exit(1);
}
if (!P2) {
fprintf(stderr, "can't create projection 2\n");
exit(1);
}
double x=39*M_PI/180 + ((double)rand()/RAND_MAX - 0.5) * M_PI/30; // 36..42
double y=((double)rand()/RAND_MAX - 0.5) * M_PI; // -90..+90
double z=((double)rand()/RAND_MAX - 0.5) * 6000; // +/- 3000m
printf("%.12f %.12f %f\n",x*180/M_PI,y*180/M_PI,z);
int i;
for (i=0; i<1000000; i++){
// z=0;
int j = pj_transform(P1,P2, 1, 1, &x, &y, &z);
if (j) {
fprintf(stderr, "can't do transform\n");
exit(1);
}
// z=0;
j = pj_transform(P2,P1, 1, 1, &x, &y, &z);
if (j) {
fprintf(stderr, "can't do transform\n");
exit(1);
}
}
printf("%.12f %.12f %f\n",x*180/M_PI,y*180/M_PI,z);
pj_free(P1);
pj_free(P2);
}
void process_projection(const projection_t *prj)
{
projPJ pj_tgt, pj_latlong;
const point_t *test_point;
int i;
double x,y;
double x1,y1;
pj_tgt=pj_init_plus(prj->init_string);
pj_latlong=pj_init_plus("+proj=latlong +ellps=WGS84");
if (!pj_latlong) {
printf("could not init latlong\n");
exit(1);
}
if (!pj_tgt) {
printf("could not init target projection: %s\n", prj->init_string);
exit(1);
}
printf("\tdescribe '%s'\n", prj->name);
for (i=0; i<(sizeof(TEST_POINTS) / sizeof(point_t)); i++) {
test_point=TEST_POINTS+i;
x=test_point->x * DEG_TO_RAD;
y=test_point->y * DEG_TO_RAD;
pj_transform(pj_latlong, pj_tgt, 1, 1, &x, &y, 0);
printf("\t\tit 'should forward transform (%f, %f) to (%f,%f)'\n", test_point->x, test_point->y, x, y);
printf("\t\t\tvar prj=new Projections.%s();\n", prj->name);
printf("\t\t\txy=prj.forward(%.20f, %.20f)\n", test_point->x, test_point->y);
printf("\t\t\txy[0].should.equal_approximately %.20f\n", x);
printf("\t\t\txy[1].should.equal_approximately %.20f\n", y);
printf("\t\tend\n\n");
x1=x;
y1=y;
pj_transform(pj_tgt, pj_latlong, 1, 1, &x1, &y1, 0);
x1*=RAD_TO_DEG;
y1*=RAD_TO_DEG;
printf("\t\tit 'should inverse transform (%f, %f) to (%f,%f)'\n", x, y, x1, y1);
printf("\t\t\tvar prj=new Projections.%s();\n", prj->name);
printf("\t\t\txy=prj.inverse(%.20f, %.20f)\n", x, y);
printf("\t\t\txy[0].should.equal_approximately %.20f\n", x1);
printf("\t\t\txy[1].should.equal_approximately %.20f\n", y1);
printf("\t\tend\n\n");
}
printf("\tend\n\n");
}
void coordconverter::convert(const std::vector<latlong>& latlongs, std::vector<coord>& coords)
{
projPJ pjMerc = pj_init_plus("+proj=tmerc +lat_0=49 +lon_0=-2 +k=0.9996012717 +x_0=400000 +y_0=-100000 +ellps=airy +datum=OSGB36 +units=m +no_defs");
if(pjMerc == NULL) throw hdsrvexception("pj_init_plus merc failed");
projPJ pjLatLon = pj_init_plus("+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs");
if(pjLatLon == NULL)
{
pj_free(pjMerc);
throw hdsrvexception("pj_init_plus proj failed");
}
for(std::vector<latlong>::const_iterator it = latlongs.begin(); it != latlongs.end(); it++)
{
double x = it->getLonDouble() * DEG_TO_RAD;
double y = it->getLatDouble() * DEG_TO_RAD;
if(pj_transform(pjLatLon, pjMerc, 1, 1, &x, &y, NULL) != 0)
{
pj_free(pjMerc);
pj_free(pjLatLon);
throw hdsrvexception("pj_transform failed");
}
coord c;
c.setNDouble(y);
c.setEDouble(x);
coords.push_back(c);
}
pj_free(pjMerc);
pj_free(pjLatLon);
}
P4Coordinate P4Singleton::transform(P4Coordinate p4c, P4Projection from, P4Projection to)
{
if (!p4c.isValid() || !from.isValid() || !to.isValid())
return P4Coordinate();
double x = p4c.x();
double y = p4c.y();
double z = p4c.z();
if (from.pj()->is_latlong)
{
x *= DEG_TO_RAD;
y *= DEG_TO_RAD;
}
int result = pj_transform(from.pj(),to.pj(),1,1,&x,&y,&z);
if (result != 0)
return P4Coordinate();
if (to.pj()->is_latlong)
{
x *= RAD_TO_DEG;
y *= RAD_TO_DEG;
}
return P4Coordinate(x,y,z);
}
static GhtErr
l2g_coordinate_reproject(const Las2GhtState *state, GhtCoordinate *coord)
{
int *pj_errno_ref;
GhtCoordinate origcoord;
/* Make a copy of the input point so we can report the original should an error occur */
origcoord = *coord;
if (pj_is_latlong(state->pj_input)) l2g_coordinate_to_rad(coord);
/* Perform the transform */
pj_transform(state->pj_input, state->pj_output, 1, 0, &(coord->x), &(coord->y), NULL);
/* For NAD grid-shift errors, display an error message with an additional hint */
pj_errno_ref = pj_get_errno_ref();
if (*pj_errno_ref != 0)
{
if (*pj_errno_ref == -38)
{
ght_warn("No no grid shift files were found, or point out of range.");
}
ght_error("%s: could not project point (%g %g): %s (%d)",
__func__,
origcoord.x, origcoord.y,
pj_strerrno(*pj_errno_ref), *pj_errno_ref
);
return GHT_ERROR;
}
if (pj_is_latlong(state->pj_output)) l2g_coordinate_to_dec(coord);
return GHT_OK;
}
/**
* Transform coordinates from one CRS into another. Wraps the same
* function of the proj library.
*
* Coordinates have to be in radians and are produced in radians.
*
* @throws osmmium::projection_error if the projection fails
*/
inline Coordinates transform(const CRS& src, const CRS& dest, Coordinates c) {
int result = pj_transform(src.get(), dest.get(), 1, 1, &c.x, &c.y, nullptr);
if (result != 0) {
throw osmium::projection_error(std::string("projection failed: ") + pj_strerrno(result));
}
return c;
}
int pj_init_and_transform( const char *from_projection, const char *to_projection, \
long point_count, double *x, double *y) {
projPJ pj_from, pj_to;
int i;
int p;
if (!(pj_from = pj_init_plus(from_projection)) ) {
printf("\nPROJ4 ERROR: There was a problem creating a PROJ4 object; "
"something is\nwrong with the PROJ4 string you supplied."
"\nOffending string: '%s'",from_projection);
exit(1);
}
if (!(pj_to = pj_init_plus(to_projection)) ) {
printf("\nPROJ4 ERROR: There was a problem creating a PROJ4 object; "
"something is\nwrong with the PROJ4 string you supplied."
"\nOffending string: '%s'",to_projection);
exit(1);
}
p = pj_transform(pj_from, pj_to, point_count, 1, x, y, NULL );
pj_free(pj_to);
pj_free(pj_from);
return(p);
}
void* thread_main(void* unused)
{
projCtx p_proj_ctxt;
projPJ p_WGS84_proj;
projPJ p_OSGB36_proj;
p_proj_ctxt=pj_ctx_alloc();
p_WGS84_proj=pj_init_plus_ctx(p_proj_ctxt,"+proj=longlat "
"+ellps=WGS84 +datum=WGS84 +no_defs");
p_OSGB36_proj=pj_init_plus_ctx(p_proj_ctxt,
"+proj=longlat +ellps=airy +datum=OSGB36 +nadgrids=OSTN02_NTv2.gsb "
"+no_defs");
while(go_on)
{
double x, y;
int proj_ret;
x = -5.2*DEG_TO_RAD;
y = 50*DEG_TO_RAD;
proj_ret = pj_transform(p_WGS84_proj,
p_OSGB36_proj, 1, 1, &x, &y, NULL );
x *= RAD_TO_DEG;
y *= RAD_TO_DEG;
/*printf("%.18f %.18f\n", x, y); */
assert(proj_ret == 0);
assert(fabs(x - -5.198965360936369962) < 1e-15);
assert(fabs(y - 49.999396034285531698) < 1e-15);
}
return NULL;
}
void Converter::convertLatLonToXY(float lat, float lon, float& x, float&y){
double tmp_x = lon * DEG_TO_RAD;
double tmp_y = lat * DEG_TO_RAD;
pj_transform(src_proj_, dst_proj_, 1, 1, &tmp_x, &tmp_y, NULL);
x = tmp_x;
y = tmp_y;
}
Point CartesianInterpolator::project(const Point &src_xy)
{
Point dest_xy;
projLP xy;
xy.u = src_xy.x;
xy.v = src_xy.y;
int status = pj_transform(m_src_proj, m_dest_proj, 1, 1, &xy.u, &xy.v, NULL);
if (status == -14 || status == -20)
{
// -14 => "latitude or longitude exceeded limits"
// -20 => "tolerance condition error"
xy.u = xy.v = HUGE_VAL;
}
else if (status != 0)
{
// TODO: Raise a Python exception instead
std::cerr << "*******************" << std::endl;
std::cerr << status << std::endl;
std::cerr << pj_strerrno(status) << std::endl;
exit(2);
}
dest_xy.x = xy.u;
dest_xy.y = xy.v;
return dest_xy;
}
void ProjectionSettings::transform(double &x, double &y, double &z)
{
pj_transform(pj_from, pj_to, 1, 1, &x, &y, &z);
x += XOffset;
y += YOffset;
z += ZOffset;
}
/*!
* \brief
* executes reprojection
*
* JNI informations:
* Class: org_proj4_Projections
* Method: transform
* Signature: ([D[D[DLjava/lang/String;Ljava/lang/String;JI)V
*
*
* \param env - parameter used by jni (see JNI specification)
* \param parent - parameter used by jni (see JNI specification)
* \param firstcoord - array of x coordinates
* \param secondcoord - array of y coordinates
* \param values - array of z coordinates
* \param src - definition of the source projection
* \param dest - definition of the destination projection
* \param pcount
* \param poffset
*/
JNIEXPORT void JNICALL Java_org_proj4_Projections_transform
(JNIEnv * env, jobject parent, jdoubleArray firstcoord, jdoubleArray secondcoord, jdoubleArray values, jstring src, jstring dest, jlong pcount, jint poffset)
{
int i;
projPJ src_pj, dst_pj;
char * srcproj_def = (char *) (*env)->GetStringUTFChars (env, src, 0);
char * destproj_def = (char *) (*env)->GetStringUTFChars (env, dest, 0);
if (!(src_pj = pj_init_plus(srcproj_def)))
exit(1);
if (!(dst_pj = pj_init_plus(destproj_def)))
exit(1);
double *xcoord = (* env)-> GetDoubleArrayElements(env, firstcoord, NULL);
double *ycoord = (* env) -> GetDoubleArrayElements(env, secondcoord, NULL);
double *zcoord = (* env) -> GetDoubleArrayElements(env, values, NULL);
pj_transform( src_pj, dst_pj, pcount,poffset, xcoord, ycoord, zcoord);
(* env)->ReleaseDoubleArrayElements(env,firstcoord,(jdouble *) xcoord,JNI_COMMIT);
(* env)->ReleaseDoubleArrayElements(env,secondcoord,(jdouble *) ycoord,JNI_COMMIT);
(* env)->ReleaseDoubleArrayElements(env,values,(jdouble *) zcoord,JNI_COMMIT);
pj_free( src_pj );
pj_free( dst_pj );
}
void gpsCallback(const sensor_msgs::NavSatFix::ConstPtr& msg)
{
tf::StampedTransform odomToBase;
tf::Vector3 pos;
tf::Quaternion quat = lastQuat;
double y = msg->latitude / 180.0 * M_PI;
double x = msg->longitude / 180.0 * M_PI;
pj_transform(pjLatLon, pjUTM, 1, 1, &x, &y, NULL);
pos.setX(x - baseX);
pos.setY(y - baseY);
try
{
tfListener->waitForTransform("/odom", "/base_footprint", msg->header.stamp, ros::Duration(1.0));
tfListener->lookupTransform("/odom", "/base_footprint", msg->header.stamp, odomToBase);
}
catch (tf::TransformException ex)
{
ROS_ERROR("%s",ex.what());
}
quat = quat * odomToBase.getRotation().inverse();
pos = pos - odomToBase.getOrigin();
tf::Transform mapToOdom(quat, pos);
tfBroadcaster->sendTransform(tf::StampedTransform(mapToOdom, lastOdom.header.stamp, "/map", "/odom"));
}
bool ProjCoordinate::convert(const ProjCoordinateSystem &system)
{
int result;
double x = d->x, y = d->y, z = d->z;
if (d->currentSystem.isLatLon()) {
x *= DEG_TO_RAD;
y *= DEG_TO_RAD;
}
result = pj_transform(d->currentSystem.d->projection,
system.d->projection,
1, 1, &x, &y, &z);
if (result) {
return false;
} else {
if (system.isLatLon()) {
x *= RAD_TO_DEG;
y *= RAD_TO_DEG;
}
d->x = x;
d->y = y;
d->z = z;
d->currentSystem = system;
return true;
}
}
JNIEXPORT int JNICALL Java_org_gvsig_crs_proj_JNIBaseCrs_operationArraySimple
(JNIEnv * env, jobject parent, jdoubleArray coord, jlong src, jlong dest)
{
int err = 0;
projPJ src_pj, dst_pj; // comprobar si se puede quitar
jdouble *xcoord;
jdouble *zcoord;
jdouble *ycoord;
src_pj = (projPJ)src;
dst_pj = (projPJ)dest;
zcoord = (* env)-> GetDoubleArrayElements(env, coord, NULL);
xcoord = zcoord++;
ycoord = zcoord++;
if(src_pj->is_latlong == 1)
{
*xcoord = *xcoord / (180/PI);
*ycoord = *ycoord / (180/PI);
}
err = pj_transform( src_pj, dst_pj,1,1, xcoord, ycoord, zcoord);
if(dst_pj->is_latlong == 1)
{
*xcoord = *xcoord * (180/PI);
*ycoord = *ycoord * (180/PI);
}
(* env)->ReleaseDoubleArrayElements(env,coord,(jdouble *) xcoord,0);
// return 1; // pendiente de analizar error
return err;
}
static VALUE cmethod_proj4_transform(VALUE module, VALUE from, VALUE to, VALUE x, VALUE y, VALUE z)
{
VALUE result;
projPJ from_pj;
projPJ to_pj;
double xval, yval, zval;
int err;
result = Qnil;
from_pj = RGEO_PROJ4_DATA_PTR(from)->pj;
to_pj = RGEO_PROJ4_DATA_PTR(to)->pj;
if (from_pj && to_pj) {
xval = rb_num2dbl(x);
yval = rb_num2dbl(y);
zval = 0.0;
if (!NIL_P(z)) {
zval = rb_num2dbl(z);
}
err = pj_transform(from_pj, to_pj, 1, 1, &xval, &yval, NIL_P(z) ? NULL : &zval);
if (!err && xval != HUGE_VAL && yval != HUGE_VAL && (NIL_P(z) || zval != HUGE_VAL)) {
result = rb_ary_new2(NIL_P(z) ? 2 : 3);
rb_ary_push(result, rb_float_new(xval));
rb_ary_push(result, rb_float_new(yval));
if (!NIL_P(z)) {
rb_ary_push(result, rb_float_new(zval));
}
}
}
return result;
}
/**
* Converts from (target) coordinates to tile coordinates.
*
* The zoom level for the coordinates is explicitly given in the
* variable map_width.
*/
void reprojection::coords_to_tile(double *tilex, double *tiley, double lon, double lat,
int map_width)
{
double x[1], y[1], z[1];
x[0] = lon;
y[0] = lat;
z[0] = 0;
if (Proj == PROJ_LATLONG)
{
x[0] *= DEG_TO_RAD;
y[0] *= DEG_TO_RAD;
}
/* since pj_tile is always spherical merc, don't bother doing anything if
* destination proj is the same. */
if (Proj != PROJ_SPHERE_MERC)
{
pj_transform(pj_target, pj_tile, 1, 1, x, y, z);
/** FIXME: pj_transform could fail if coordinates are outside +/- 85 degrees latitude */
}
/* if ever pj_tile were allowed to be PROJ_LATLONG then results would have to
* be divided by DEG_TO_RAD here. */
*tilex = map_width * (0.5 + x[0] / EARTH_CIRCUMFERENCE);
*tiley = map_width * (0.5 - y[0] / EARTH_CIRCUMFERENCE);
}
float CMapDEM::getElevation(double lon, double lat)
{
if(pjsrc == 0) return WPT_NOFLOAT;
qint16 e[4];
double u = lon;
double v = lat;
pj_transform(pjtar, pjsrc, 1, 0, &u, &v, 0);
// qDebug() << u << xref1 << xscale;
double xoff = (u - xref1) / xscale;
double yoff = (v - yref1) / yscale;
double x = xoff - floor(xoff);
double y = yoff - floor(yoff);
// qDebug() << xoff << yoff << x << y;
CPLErr err = dataset->RasterIO(GF_Read, floor(xoff), floor(yoff), 2, 2, &e, 2, 2, GDT_Int16, 1, 0, 0, 0, 0);
if(err == CE_Failure)
{
return WPT_NOFLOAT;
}
double b1 = e[0];
double b2 = e[1] - e[0];
double b3 = e[2] - e[0];
double b4 = e[0] - e[1] - e[2] + e[3];
float ele = b1 + b2 * x + b3 * y + b4 * x * y;
return ele;
}
Point SphericalInterpolator::project(const Point &lonlat)
{
Point xy;
projLP dest;
//std::cerr << "lon/lat: " << lonlat.x << ", " << lonlat.y;
dest.u = lonlat.x * DEG_TO_RAD;
dest.v = lonlat.y * DEG_TO_RAD;
//std::cerr << " => " << dest.u << ", " << dest.v;
int status = pj_transform(m_src_proj, m_dest_proj, 1, 1, &dest.u, &dest.v, NULL);
if (status == -14 || status == -20)
{
// -14 => "latitude or longitude exceeded limits"
// -20 => "tolerance condition error"
dest.u = dest.v = HUGE_VAL;
}
else if (status != 0)
{
// TODO: Raise a Python exception instead
std::cerr << "*******************" << std::endl;
std::cerr << status << std::endl;
std::cerr << pj_strerrno(status) << std::endl;
exit(2);
}
//std::cerr << " -> " << dest.u << ", " << dest.v;
xy.x = dest.u;
xy.y = dest.v;
//std::cerr << "xy: " << xy.x << ", " << xy.y << std::endl;
return xy;
}
ERMsg CProjection::Reproject(projPJ src, projPJ dst, long point_count, int point_offset, double *x, double *y, double *z)
{
ERMsg msg;
if (pj_is_latlong(src))
{
if (x != NULL)
*x *= DEG_TO_RAD;
if (y != NULL)
*y *= DEG_TO_RAD;
if (z != NULL)
*z *= DEG_TO_RAD;
}
if (pj_transform(src, dst, point_count, point_offset, x, y, z) == 0)
{
msg.ajoute("ERROR: unable to re-projection point (" + ToString(*x) + ", " + ToString(*y) + ((z != NULL) ? ToString(*z) : "") + ")");
}
if (pj_is_latlong(dst))
{
if (x != NULL)
*x *= RAD_TO_DEG;
if (y != NULL)
*y *= RAD_TO_DEG;
if (z != NULL)
*z *= RAD_TO_DEG;
}
return msg;
}
void GridGeometryTest::testGetGeometryHirlam10()
{
std::ostringstream exp;
double x0 = 5.75 * DEG_TO_RAD;
double y0 = -13.25 * DEG_TO_RAD;
double x1 = (5.75+(247*0.1)) * DEG_TO_RAD;
double y1 = -13.25 * DEG_TO_RAD;
double x2 = (5.75+(247*0.1)) * DEG_TO_RAD;
double y2 = (-13.25+(399*0.1)) * DEG_TO_RAD;
double x3 = 5.75 * DEG_TO_RAD;
double y3 = (-13.25+(399*0.1)) * DEG_TO_RAD;
int error = pj_transform( hirlam10Proj, targetProj, 1, 0, &x0, &y0, NULL );
if ( error ) {
std::ostringstream msg;
msg << "Error during reprojection: " << pj_strerrno(error) << ".";
CPPUNIT_FAIL( msg.str() );
}
error = pj_transform( hirlam10Proj, targetProj, 1, 0, &x1, &y1, NULL );
if ( error ) {
std::ostringstream msg;
msg << "Error during reprojection: " << pj_strerrno(error) << ".";
CPPUNIT_FAIL( msg.str() );
}
error = pj_transform( hirlam10Proj, targetProj, 1, 0, &x2, &y2, NULL );
if ( error ) {
std::ostringstream msg;
msg << "Error during reprojection: " << pj_strerrno(error) << ".";
CPPUNIT_FAIL( msg.str() );
}
error = pj_transform( hirlam10Proj, targetProj, 1, 0, &x3, &y3, NULL );
if ( error ) {
std::ostringstream msg;
msg << "Error during reprojection: " << pj_strerrno(error) << ".";
CPPUNIT_FAIL( msg.str() );
}
exp << "POLYGON((";
exp << wdb::round(x0 * RAD_TO_DEG, 4) << " " << wdb::round (y0 * RAD_TO_DEG, 4) << ",";
exp << wdb::round(x1 * RAD_TO_DEG, 4) << " " << wdb::round (y1 * RAD_TO_DEG, 4) << ",";
exp << wdb::round(x2 * RAD_TO_DEG, 4) << " " << wdb::round (y2 * RAD_TO_DEG, 4) << ",";
exp << wdb::round(x3 * RAD_TO_DEG, 4) << " " << wdb::round (y3 * RAD_TO_DEG, 4) << ",";
exp << wdb::round(x0 * RAD_TO_DEG, 4) << " " << wdb::round (y0 * RAD_TO_DEG, 4) << "))";
const std::string expected = exp.str();
std::string geometry = grid->wktRepresentation();
CPPUNIT_ASSERT_EQUAL( expected, geometry);
}
void GridGeometryTest::testGetUpperRightCorner()
{
double x = 30.45 * DEG_TO_RAD;
double y = 26.65 * DEG_TO_RAD;
int error = pj_transform( hirlam10Proj, targetProj,
1, 0, &x, &y, NULL );
const GridGeometry::Point p = grid->point(GridGeometry::UpperRight);
CPPUNIT_ASSERT_DOUBLES_EQUAL(x * RAD_TO_DEG, p.x, 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL(y * RAD_TO_DEG, p.y, 0.001);
}
QPointF Projection::transformFrom(Projection *pjOther, QPointF p)
{
projUV uv;
double z = 0.0;
uv.u = p.x() / pjOther->scale;
uv.v = p.y() / pjOther->scale;
pj_transform(pjOther->pj, pj, 1, 0, &uv.u, &uv.v, &z);
return QPointF(uv.u, uv.v) * scale;
}
// reproject shapes
shapes_v
shape_proj(
const shapes_v* shapes,
const char* from,
const char* to){
projPJ old_prj = pj_init_plus(from);
projPJ new_prj = pj_init_plus(to);
shapes_v shapes_prj;
kv_init(shapes_prj);
shapes_prj.min = (point_t){ INFINITY, INFINITY};
shapes_prj.max = (point_t){-INFINITY,-INFINITY};
double k = 0.0;
for(uint32_t s=0; s<shapes->n; s++) {
shape_v* shape = &shapes->a[s];
shape_v shape_prj;
kv_init(shape_prj);
for(uint32_t p=0; p<shape->n; p++) {
point_t pnt = shape->a[p];
pnt.x *= DEG_TO_RAD;
pnt.y *= DEG_TO_RAD;
int32_t err = pj_transform(old_prj, new_prj, 1, 0, &pnt.x, &pnt.y, NULL);
if (err) {
fprintf(stderr, "ERR%d %s\n", err, pj_strerrno(err));
continue;
}
// cumulitive average for center
if(k>=1.0) {
shapes_prj.center.x = (k-1.0)/k*shapes_prj.center.x + pnt.x/k;
shapes_prj.center.y = (k-1.0)/k*shapes_prj.center.y + pnt.y/k;
}else {
shapes_prj.center.x = pnt.x;
shapes_prj.center.y = pnt.y;
}
k+=1.0;
// new bounds
if(pnt.x>shapes_prj.max.x) shapes_prj.max.x = pnt.x;
if(pnt.y>shapes_prj.max.y) shapes_prj.max.y = pnt.y;
if(pnt.x<shapes_prj.min.x) shapes_prj.min.x = pnt.x;
if(pnt.y<shapes_prj.min.y) shapes_prj.min.y = pnt.y;
kv_push(point_t, shape_prj, pnt);
}
kv_push(shape_v, shapes_prj, shape_prj);
}
pj_free(old_prj);
pj_free(new_prj);
return shapes_prj;
}
static int test_nad27_ll(double lat, double lon,
double expected_lat, double expected_lon)
{
double lats[1];
double lons[1];
double hts[1];
char input_projection_info[255];
char output_projection_info[255];
projPJ input_projection, output_projection;
sprintf(input_projection_info, "+proj=latlong +datum=NAD27");
sprintf(output_projection_info, "+proj=latlong +datum=NAD83");
input_projection = pj_init_plus(input_projection_info);
output_projection = pj_init_plus(output_projection_info);
lats[0] = lat * D2R;
lons[0] = lon * D2R;
hts[0] = 0;
pj_transform (input_projection, output_projection, 1, 1,
lats, lons, hts);
if (pj_errno != 0) {
asfPrintWarning("libproj error: %s\n", pj_strerrno(pj_errno));
}
pj_free(input_projection);
pj_free(output_projection);
lats[0] *= R2D;
lons[0] *= R2D;
CU_ASSERT(double_equals(lats[0], expected_lat, 6));
CU_ASSERT(double_equals(lons[0], expected_lon, 6));
if (double_equals(lats[0], expected_lat, 6) &&
double_equals(lons[0], expected_lon, 6))
{
//asfPrintStatus("Proj (fwd): %f, %f ... OK\n", lat, lon);
return TRUE;
}
else
{
asfPrintStatus("Proj (fwd): %f, %f ... ERROR\n", lat, lon);
asfPrintStatus("Result: %.10f %.10f (%.10f)\n",
lats[0], lons[0], hts[0]);
asfPrintStatus("Expected: %.10f %.10f\n",
expected_lat, expected_lon);
return FALSE;
}
}
void GridGeometryTest::testGetLowerLeftCorner()
{
double x = 5.75 * DEG_TO_RAD;
double y = -13.25 * DEG_TO_RAD;
double alt = 0.0;
int error = pj_transform( hirlam10Proj, targetProj,
1, 0, &x, &y, &alt );
const GridGeometry::Point p = grid->point(GridGeometry::LowerLeft);
CPPUNIT_ASSERT_DOUBLES_EQUAL(x * RAD_TO_DEG, p.x, 0.001);
CPPUNIT_ASSERT_DOUBLES_EQUAL(y * RAD_TO_DEG, p.y, 0.001);
}
/*--------------------------------------------------------------------*/
int mb_proj_transform(int verbose,
void *pjsrcptr,
void *pjdstptr,
int npoint,
double *x, double *y, double *z,
int *error)
{
char *function_name = "mb_proj_transform";
int status = MB_SUCCESS;
int i;
/* print input debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> called\n",function_name);
fprintf(stderr,"dbg2 Revision id: %s\n",rcs_id);
fprintf(stderr,"dbg2 Input arguments:\n");
fprintf(stderr,"dbg2 verbose: %d\n",verbose);
fprintf(stderr,"dbg2 pjptr: %p\n",(void *)pjsrcptr);
fprintf(stderr,"dbg2 pjptr: %p\n",(void *)pjdstptr);
fprintf(stderr,"dbg2 npoint: %d\n",npoint);
for (i=0;i<npoint;i++)
fprintf(stderr,"dbg2 point[%d]: x:%f y:%f z:%f\n", i, x[i], y[i], z[i]);
}
/* do transform */
if (pjsrcptr != NULL && pjdstptr != NULL)
{
pj_transform((projPJ *)pjsrcptr, (projPJ *)pjdstptr, npoint, 1, x, y, z);
}
/* assume success */
*error = MB_ERROR_NO_ERROR;
status = MB_SUCCESS;
/* print output debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> completed\n",function_name);
fprintf(stderr,"dbg2 Revision id: %s\n",rcs_id);
fprintf(stderr,"dbg2 Return values:\n");
fprintf(stderr,"dbg2 npoint: %d\n",npoint);
for (i=0;i<npoint;i++)
fprintf(stderr,"dbg2 point[%d]: x:%f y:%f z:%f\n", i, x[i], y[i], z[i]);
fprintf(stderr,"dbg2 error: %d\n",*error);
fprintf(stderr,"dbg2 Return status:\n");
fprintf(stderr,"dbg2 status: %d\n",status);
}
/* return status */
return(status);
}
//---------------------------------------------------------
bool CSG_CRSProjector::Get_Projection(double &x, double &y) const
{
if( !m_pSource || !m_pTarget )
{
return( false );
}
if( pj_is_latlong((PJ *)m_pSource) )
{
x *= DEG_TO_RAD;
y *= DEG_TO_RAD;
}
if( m_pGCS ) // precise datum conversion
{
if( pj_transform((PJ *)m_pSource, (PJ *)m_pGCS , 1, 0, &x, &y, NULL) != 0
|| pj_transform((PJ *)m_pGCS , (PJ *)m_pTarget, 1, 0, &x, &y, NULL) != 0 )
{
return( false );
}
}
else // direct projection
{
if( pj_transform((PJ *)m_pSource, (PJ *)m_pTarget, 1, 0, &x, &y, NULL) != 0 )
{
return( false );
}
}
if( pj_is_latlong((PJ *)m_pTarget) )
{
x *= RAD_TO_DEG;
y *= RAD_TO_DEG;
}
return( true );
}
