void draw_sec(CHpoints *p) {
dpoint c;
CHpoints *p1,*p2,*p3;
double radius;
if ((length2(before(p)->node,p->node) >
length2(p->node,next(p)->node)) &&
(length2(before(p)->node,p->node) >
length2(before(p)->node,next(p)->node)))
p2=next(p); /* the angle at next(p) is the biggest */
else if ((length2(p->node,next(p)->node) >
length2(before(p)->node,next(p)->node)) &&
(length2(p->node,next(p)->node) >
length2(p->node,before(p)->node)))
p2=before(p); /* the angle at before(p) is the biggest */
else
p2=p; /* the angle at p is the biggest */
p1=before(p2);
p3=next(p2);
if (angle(p1,p2,p3)<0) {
c.x=(midpoint(p1->node,p3->node)).x; /* center is midpoint of */
c.y=(midpoint(p1->node,p3->node)).y; /* p1 and p3 */
radius=sqrt((double)length2(p1->node,p3->node))/2.00;
}
else {
c=centre(p1->node,p2->node,p3->node);
radius=sqrt((double)radius2(p->node,c));
}
printf("The center is (%d,%d)\n",(int)c.x,(int)c.y);
printf("The radius is %9.2f\n",radius);
}
/* Initialize the Mercator projection
-----------------------------------*/
int merinvint(
double r_maj, /* major axis */
double r_min, /* minor axis */
double center_lon, /* center longitude */
double center_lat, /* center latitude */
double false_east, /* x offset in meters */
double false_north) /* y offset in meters */
{
double temp; /* temporary variable */
double e0fn(),e1fn(),e2fn(),e3fn(); /* functions */
/* Place parameters in static storage for common use
-------------------------------------------------*/
r_major = r_maj;
r_minor = r_min;
lon_center = center_lon;
lat_origin = center_lat;
false_northing = false_north;
false_easting = false_east;
temp = r_minor / r_major;
es = 1.0 - SQUARE(temp);
e = sqrt(es);
m1 = cos(center_lat)/(sqrt(1.0 - es * sin(center_lat) * sin(center_lat)));
/* Report parameters to the user
-----------------------------*/
ptitle("MERCATOR");
radius2(r_major, r_minor);
cenlonmer(lon_center);
origin(lat_origin);
offsetp(false_easting,false_northing);
return(OK);
}
CHpoints *maximize_radius_and_angle(CHpoints *S) {
CHpoints *p1,*p2,*p3;
key key1,key2;
p2=CHdelete_max(&CHSplaytree);
p1=before(p2);
p3=next(p2);
key1.radius=radius2(p1->node,
centre(before(p1)->node,p1->node,p2->node));
key1.angle=angle(before(p1),p1,p2);
key1.number=p1->number;
CHdelete(&CHSplaytree,key1); /* delete before(p) */
key2.radius=radius2(p3->node,
centre(p2->node,p3->node,next(p3)->node));
key2.angle=angle(p2,p3,next(p3));
key2.number=p3->number;
CHdelete(&CHSplaytree,key2); /* delete next(p) */
return p2;
}
/* Initialize the Sinusoidal projection
------------------------------------*/
int sininvint(
double r_maj, /* major axis */
double r_min, /* minor axis */
double center_long, /* (I) Center longitude */
double false_east, /* x offset in meters */
double false_north) /* y offset in meters */
{
/* Place parameters in static storage for common use
-------------------------------------------------*/
R = r_maj;
if(fabs(r_min) < EPSLN ) /* sphere */
{
r_major = r_maj;
r_minor = r_maj;
}
else /* sphere or ellipsoide */
{
r_major = r_maj;
r_minor = r_min;
}
lon_center = center_long;
false_easting = false_east;
false_northing = false_north;
es = 1.0 - SQUARE(r_minor / r_major);
e = sqrt(es);
if(e < 0.00001)
{
ind = 1; /* sphere */
}
else
{
double e12, e13, e14;
ind = 0; /* ellipsoid */
e1 = (1.0 - sqrt(1.0 - es))/(1.0 + sqrt(1.0 - es));
e12 = e1 * e1;
e13 = e12 * e1;
e14 = e13 * e1;
imu = (1.0 - (es/4.0) - (3.0 * es * es / 64.0) -
(5.0 * es * es * es /256.0));
e2 = ((3.0 * e1 /2.0) - (27.0 * e13 / 32.0));
e3 = ((21.0 * e12 / 16.0) - (55.0 * e14 / 32.0));
e4 = (151.0 * e13 / 96.0);
e5 = (1097.0 * e14 / 512.0);
}
/* Report parameters to the user
-----------------------------*/
ptitle("SINUSOIDAL");
radius2(r_major, r_minor);
cenlon(center_long);
offsetp(false_easting,false_northing);
return(OK);
}
/* Initialize the ALASKA CONFORMAL projection
-----------------------------------------*/
long alconinvint
(
double r_maj, /* Major axis */
double r_min, /* Minor axis */
double false_east, /* x offset in meters */
double false_north /* y offset in meters */
)
{
double es;
double chi;
double esphi;
/* Place parameters in static storage for common use
-------------------------------------------------*/
r_major = r_maj;
r_minor = r_min;
false_easting = false_east;
false_northing = false_north;
lon_center = -152.0 * D2R;
lat_center = 64.0 * D2R;
n = 6;
es = .006768657997291094;
e = sqrt(es);
acoef[1]= 0.9945303;
acoef[2]= 0.0052083;
acoef[3]= 0.0072721;
acoef[4]= -0.0151089;
acoef[5]= 0.0642675;
acoef[6]= 0.3582802;
bcoef[1]= 0.0;
bcoef[2]= -.0027404;
bcoef[3]= 0.0048181;
bcoef[4]= -0.1932526;
bcoef[5]= -0.1381226;
bcoef[6]= -0.2884586;
esphi = e * sin(lat_center);
chi = 2.0 * atan(tan((HALF_PI + lat_center)/2.0) *
pow(((1.0 - esphi)/(1.0 + esphi)),(e/2.0))) - HALF_PI;
gctp_sincos(chi,&sin_p26,&cos_p26);
/* Report parameters to the user
-----------------------------*/
ptitle("ALASKA CONFORMAL");
radius2(r_major,r_minor);
cenlon(lon_center);
cenlat(lat_center);
offsetp(false_easting,false_northing);
return(GCTP_OK);
}
bool
ColliderComponent::isColliding(ColliderComponent &c, float d, CollisionData *data) const
{
if (m_p->movement && c.position()) {
const Math::Point2 l_pos_a = m_p->movement->simulate(d);
const Math::Point2 &l_pos_b = c.position()->position();
switch(m_p->body) {
case btSphere: {
float l_distance2 = l_pos_b.difference(l_pos_a).magnitude2();
l_distance2 -= c.radius2() + radius2();
if (l_distance2 < 0) {
if (data)
data->sphere.penetration2 = l_distance2;
return(true);
}
} break;
case btBox: {
const Math::Size2f l_size_a = m_p->size->size() / 2.f;
const Math::Size2f l_size_b = c.size()->size() / 2.f;
const float l =
(l_pos_a.x + l_size_a.width) - (l_pos_b.x - l_size_b.width);
const float r =
(l_pos_b.x + l_size_b.width) - (l_pos_a.x - l_size_a.width);
const float t =
(l_pos_b.y + l_size_b.height) - (l_pos_a.y - l_size_a.height);
const float b =
(l_pos_a.y + l_size_a.height) - (l_pos_b.y - l_size_b.height);
if (data) {
data->rect.left = l;
data->rect.right = r;
data->rect.top = t;
data->rect.bottom = b;
}
if (l > 0 && r > 0 && t > 0 && b > 0)
return(true);
} break;
case btCapsule:
default: return(false);
}
}
return(false);
}
bool Brush::operator==(const Brush& brush) const
{
return radius1() == brush.radius1() && radius2() == brush.radius2() &&
qAbs(hardness1() - brush.hardness1()) <= 1.0/256.0 &&
qAbs(hardness2() - brush.hardness2()) <= 1.0/256.0 &&
qAbs(opacity1() - brush.opacity1()) <= 1.0/256.0 &&
qAbs(opacity2() - brush.opacity2()) <= 1.0/256.0 &&
color1() == brush.color1() &&
color2() == brush.color2() &&
spacing() == brush.spacing() &&
subpixel() == brush.subpixel() &&
incremental() == brush.incremental() &&
blendingMode() == brush.blendingMode();
}
/* Initialize the Polar Stereographic projection
--------------------------------------------*/
long psinvint
(
double r_maj, /* major axis */
double r_min, /* minor axis */
double c_lon, /* center longitude */
double c_lat, /* center latitude */
double false_east, /* x offset in meters */
double false_north /* y offset in meters */
)
{
double temp; /* temporary variable */
double con1; /* temporary angle */
double sinphi; /* sin value */
double cosphi; /* cos value */
double es; /* eccentricity squared */
r_major = r_maj;
r_minor = r_min;
false_easting = false_east;
false_northing = false_north;
temp = r_minor / r_major;
es = 1.0 - SQUARE(temp);
e = sqrt(es);
e4 = e4fn(e);
center_lon = c_lon;
center_lat = c_lat;
if (c_lat < 0)
fac = -1.0;
else
fac = 1.0;
ind = 0;
if (fabs(fabs(c_lat) - HALF_PI) > EPSLN)
{
ind = 1;
con1 = fac * center_lat;
gctp_sincos(con1,&sinphi,&cosphi);
mcs = msfnz(e,sinphi,cosphi);
tcs = tsfnz(e,con1,sinphi);
}
/* Report parameters to the user
-----------------------------*/
ptitle("POLAR STEREOGRAPHIC");
radius2(r_major, r_minor);
cenlon(center_lon);
offsetp(false_east,false_north);
return(GCTP_OK);
}
// Initialize the Polar Stereographic projection
long Projectoid::psinvint(
double r_maj, // major axis
double r_min, // minor axis
double c_lon, // center longitude
double c_lat, // center latitude
double false_east, // x offset in meters
double false_north) // y offset in meters
{
double temp; // temporary variable
double con1; // temporary angle
double sinphi; // sin value
double cosphi; // cos value
double es; // eccentricity squared
r_major = r_maj;
r_minor = r_min;
false_easting = false_east;
false_northing = false_north;
temp = r_minor / r_major;
es = 1.0 - SQUARE(temp);
e = sqrt(es);
e4 = e4fn(e);
center_lon = c_lon;
center_lat = c_lat;
if (c_lat < 0)
fac = -1.0;
else
fac = 1.0;
ind = 0;
if (fabs(fabs(c_lat) - HALF_PI) > EPSLN)
{
ind = 1;
con1 = fac * center_lat;
sincos(con1, &sinphi, &cosphi);
mcs = msfnz(e, sinphi, cosphi);
tcs = tsfnz(e, con1, sinphi);
}
// Report parameters to the user
ptitle("POLAR STEREOGRAPHIC");
radius2(r_major, r_minor);
cenlon(center_lon);
offsetp(false_east, false_north);
InverseOK[WCS_PROJECTIONCODE_PS] = 1;
InverseTransform = &Projectoid::psinv;
return(OK);
}
// Initialize the Universal Transverse Mercator (UTM) projection
long Projectoid::utmforint(
double r_maj, // major axis
double r_min, // minor axis
double scale_fact, // scale factor
long zone) // zone number
{
double temp; // temporary variable
if ((abs(zone) < 1) || (abs(zone) > 60))
{
p_error("Illegal zone number", "utm-forint");
return(11);
}
r_major = r_maj;
r_minor = r_min;
scale_factor = scale_fact;
lat_origin = 0.0;
lon_center = ((6 * abs(zone)) - 183) * D2R;
false_easting = 500000.0;
false_northing = (zone < 0) ? 10000000.0 : 0.0;
temp = r_minor / r_major;
es = 1.0 - SQUARE(temp);
e = sqrt(es);
e0 = e0fn(es);
e1 = e1fn(es);
e2 = e2fn(es);
e3 = e3fn(es);
ml0 = r_major * mlfn(e0, e1, e2, e3, lat_origin);
esp = es / (1.0 - es);
if (es < .00001)
ind = 1;
// Report parameters to the user
ptitle("UNIVERSAL TRANSVERSE MERCATOR (UTM)");
genrpt_long(zone, "Zone: ");
radius2(r_major, r_minor);
genrpt(scale_factor, "Scale Factor at C. Meridian: ");
cenlonmer(lon_center);
ForwardOK[WCS_PROJECTIONCODE_UTM] = 1;
ForwardTransform = &Projectoid::utmfor;
return(OK);
}
/* Initialize the Cylinderical Equal Area projection
-------------------------------------------------*/
int ceaforint(
double r_maj, /* major axis */
double r_min, /* minor axis */
double center_lon, /* center longitude */
double center_lat, /* center latitude */
double false_east, /* x offset in meters */
double false_north) /* y offset in meters */
{
double temp; /* temporary variable */
/* Place parameters in static storage for common use
-------------------------------------------------*/
r_major = r_maj;
r_minor = r_min;
lon_center = center_lon;
lat_truesc = center_lat;
false_northing = false_north;
false_easting = false_east;
temp = r_minor / r_major;
es = 1.0 - SQUARE(temp);
e = sqrt(es);
if(es < 0.00001)
{
ind = 1;
}
else
{
ind = 0;
}
cosphi1 = cos(lat_truesc);
sinphi1 = sin(lat_truesc);
kz = cosphi1/(sqrt(1.0 - (es*sinphi1*sinphi1)));
/* Report parameters to the user
-----------------------------*/
ptitle("Cylinderical Equal Area");
radius2(r_major, r_minor);
cenlonmer(lon_center);
true_scale(lat_truesc);
offsetp(false_easting,false_northing);
return(OK);
}
/* Initialize the Universal Transverse Mercator (UTM) projection
-------------------------------------------------------------*/
long utmforint
(
double r_maj, /* major axis */
double r_min, /* minor axis */
double scale_fact, /* scale factor */
long zone /* zone number */
)
{
double temp; /* temporary variable */
if ((abs(zone) < 1) || (abs(zone) > 60))
{
p_error("Illegal zone number","utm-forint");
return(11);
}
r_major = r_maj;
r_minor = r_min;
scale_factor = scale_fact;
lat_origin = 0.0;
lon_center = ((6 * abs(zone)) - 183) * D2R;
false_easting = 500000.0;
false_northing = (zone < 0) ? 10000000.0 : 0.0;
temp = r_minor / r_major;
es = 1.0 - SQUARE(temp);
e0 = e0fn(es);
e1 = e1fn(es);
e2 = e2fn(es);
e3 = e3fn(es);
ml0 = r_major * mlfn(e0, e1, e2, e3, lat_origin);
esp = es / (1.0 - es);
if (es < .00001)
ind = 1;
/* Report parameters to the user
-----------------------------*/
ptitle("UNIVERSAL TRANSVERSE MERCATOR (UTM)");
genrpt_long(zone, "Zone: ");
radius2(r_major, r_minor);
genrpt(scale_factor,"Scale Factor at C. Meridian: ");
cenlonmer(lon_center);
return(GCTP_OK);
}
// Initialize the POLYCONIC projection
long Projectoid::polyinvint(
double r_maj, // major axis
double r_min, // minor axis
double center_lon_init, // center longitude
double center_lat_init, // center latitude
double false_east, // x offset in meters
double false_north) // y offset in meters
{
double temp; // temporary variable
// Place parameters in static storage for common use
r_major = r_maj;
r_minor = r_min;
lon_center = center_lon_init;
lat_origin = center_lat_init;
false_northing = false_north;
false_easting = false_east;
temp = r_minor / r_major;
es = 1.0 - SQUARE(temp);
e = sqrt(es);
e0 = e0fn(es);
e1 = e1fn(es);
e2 = e2fn(es);
e3 = e3fn(es);
ml0 = mlfn(e0, e1, e2, e3, lat_origin);
// Report parameters to the user
ptitle("POLYCONIC");
radius2(r_major, r_minor);
cenlonmer(lon_center);
origin(lat_origin);
offsetp(false_easting, false_northing);
InverseOK[WCS_PROJECTIONCODE_POLYC] = 1;
InverseTransform = &Projectoid::polyinv;
return(OK);
}
/* Initialize the POLYCONIC projection
----------------------------------*/
long polyforint
(
double r_maj, /* major axis */
double r_min, /* minor axis */
double center_lon, /* center longitude */
double center_lat, /* center latitude */
double false_east, /* x offset in meters */
double false_north /* y offset in meters */
)
{
double temp; /* temporary variable */
/* Place parameters in static storage for common use
-------------------------------------------------*/
r_major = r_maj;
r_minor = r_min;
lon_center = center_lon;
lat_origin = center_lat;
false_northing = false_north;
false_easting = false_east;
temp = r_minor / r_major;
es = 1.0 - SQUARE(temp);
e = sqrt(es);
e0 = e0fn(es);
e1 = e1fn(es);
e2 = e2fn(es);
e3 = e3fn(es);
ml0 = mlfn(e0, e1, e2, e3, lat_origin);
/* Report parameters to the user
-----------------------------*/
ptitle("POLYCONIC");
radius2(r_major, r_minor);
cenlonmer(lon_center);
origin(lat_origin);
offsetp(false_easting,false_northing);
return(GCTP_OK);
}
// Could cache this if it is a common request
float Ftbs::radius() const {
return std::sqrt(radius2());
}
long somforint( double r_major, double r_minor, long satnum, long path, double alf_in, double lon, double false_east,
double false_north, double time, long start1, long flag)
/*double r_major; major axis
double r_minor; minor axis
long satnum; Landsat satellite number (1,2,3,4,5)
long path; Landsat path number
double alf_in;
double lon;
double false_east; x offset in meters
double false_north; y offset in meters
double time;
long start1;
long flag; */
{
long i;
double alf,e2c,e2s,one_es;
double dlam,fb,fa2,fa4,fc1,fc3,suma2,suma4,sumc1,sumc3,sumb;
/* Place parameters in static storage for common use
-------------------------------------------------*/
false_easting = false_east;
false_northing = false_north;
a = r_major;
b = r_minor;
es = 1.0 - SQUARE(r_minor/r_major);
if (flag != 0)
{
alf = alf_in;
p21 = time / 1440.0;
lon_center = lon;
start = start1;
}
else
{
if (satnum < 4)
{
alf = 99.092 * D2R;
p21=103.2669323/1440.0;
lon_center = (128.87 - (360.0/251.0 * path)) * D2R;
}
else
{
alf = 98.2 * D2R;
p21=98.8841202/1440.0;
lon_center = (129.30 - (360.0/233.0 * path)) * D2R;
/*
lon_center = (-129.30557714 - (360.0/233.0 * path)) * D2R;
*/
}
start=0.0;
}
/* Report parameters to the user (to device set up prior to this call)
-------------------------------------------------------------------*/
ptitle("SPACE OBLIQUE MERCATOR");
radius2(a,b);
if (flag == 0)
{
genrpt_long(path, "Path Number: ");
genrpt_long(satnum, "Satellite Number: ");
}
genrpt(alf*R2D, "Inclination of Orbit: ");
genrpt(lon_center*R2D,"Longitude of Ascending Orbit: ");
offsetp(false_easting,false_northing);
genrpt(LANDSAT_RATIO, "Landsat Ratio: ");
ca=cos(alf);
if (fabs(ca)<1.e-9) ca=1.e-9;
sa=sin(alf);
e2c=es*ca*ca;
e2s=es*sa*sa;
w=(1.0-e2c)/(1.0-es);
w=w*w-1.0;
one_es=1.0-es;
q = e2s / one_es;
t = (e2s*(2.0-es)) / (one_es*one_es);
u= e2c / one_es;
xj = one_es*one_es*one_es;
dlam=0.0;
som_series(&fb,&fa2,&fa4,&fc1,&fc3,&dlam);
suma2=fa2;
suma4=fa4;
sumb=fb;
sumc1=fc1;
sumc3=fc3;
for(i=9;i<=81;i+=18)
{
dlam=i;
som_series(&fb,&fa2,&fa4,&fc1,&fc3,&dlam);
suma2=suma2+4.0*fa2;
suma4=suma4+4.0*fa4;
sumb=sumb+4.0*fb;
sumc1=sumc1+4.0*fc1;
sumc3=sumc3+4.0*fc3;
}
for(i=18; i<=72; i+=18)
{
dlam=i;
som_series(&fb,&fa2,&fa4,&fc1,&fc3,&dlam);
suma2=suma2+2.0*fa2;
suma4=suma4+2.0*fa4;
sumb=sumb+2.0*fb;
sumc1=sumc1+2.0*fc1;
sumc3=sumc3+2.0*fc3;
}
dlam=90.0;
som_series(&fb,&fa2,&fa4,&fc1,&fc3,&dlam);
suma2=suma2+fa2;
suma4=suma4+fa4;
sumb=sumb+fb;
sumc1=sumc1+fc1;
sumc3=sumc3+fc3;
a2=suma2/30.0;
a4=suma4/60.0;
b=sumb/30.0;
c1=sumc1/15.0;
c3=sumc3/45.0;
return(OK);
}
// Initialize the Lambert Conformal Conic projection
long Projectoid::lamccinvint(
double r_maj, // major axis
double r_min, // minor axis
double lat1, // first standard parallel
double lat2, // second standard parallel
double c_lon, // center longitude
double c_lat, // center latitude
double false_east, // x offset in meters
double false_north) // y offset in meters
{
double sin_po; // sin value
double cos_po; // cos value
double con; // temporary sin value
double ms1; // small m 1
double ms2; // small m 2
double temp; // temporary variable
double ts0; // small t 0
double ts1; // small t 1
double ts2; // small t 2
r_major = r_maj;
r_minor = r_min;
false_easting = false_east;
false_northing = false_north;
// Standard Parallels cannot be equal and on opposite sides of the equator
if (fabs(lat1 + lat2) < EPSLN)
{
p_error("Equal Latitiudes for St. Parallels on opposite sides of equator", "lamcc-inv");
return(41);
}
temp = r_minor / r_major;
es = 1.0 - SQUARE(temp);
e = sqrt(es);
center_lon = c_lon;
center_lat = c_lat;
sincos(lat1, &sin_po, &cos_po);
con = sin_po;
ms1 = msfnz(e, sin_po, cos_po);
ts1 = tsfnz(e, lat1, sin_po);
sincos(lat2, &sin_po, &cos_po);
ms2 = msfnz(e, sin_po, cos_po);
ts2 = tsfnz(e, lat2, sin_po);
sin_po = sin(center_lat);
ts0 = tsfnz(e, center_lat, sin_po);
if (fabs(lat1 - lat2) > EPSLN)
ns = log(ms1 / ms2) / log(ts1 / ts2);
else
ns = con;
f0 = ms1 / (ns * pow(ts1, ns));
rh = r_major * f0 * pow(ts0, ns);
// Report parameters to the user
ptitle("LAMBERT CONFORMAL CONIC");
radius2(r_major, r_minor);
stanparl(lat1, lat2);
cenlonmer(center_lon);
origin(c_lat);
offsetp(false_easting, false_northing);
InverseOK[WCS_PROJECTIONCODE_LAMCC] = 1;
InverseTransform = &Projectoid::lamccinv;
return(OK);
}
/* Initialize the General Lambert Azimuthal Equal Area projection
--------------------------------------------------------------*/
int lamazforint(
double r_maj, /* major axis */
double r_min, /* minor axis */
double center_long, /* (I) Center longitude */
double center_lat, /* (I) Center latitude */
double false_east, /* x offset in meters */
double false_north) /* y offset in meters */
{
/* Place parameters in static storage for common use
-------------------------------------------------*/
R = r_maj;
if(fabs(r_min) < EPSLN ) /* sphere */
{
r_major = r_maj;
r_minor = r_maj;
}
else /* sphere or ellipsoide */
{
r_major = r_maj;
r_minor = r_min;
}
lon_center = center_long;
lat_center = center_lat;
false_easting = false_east;
false_northing = false_north;
tsincos(center_lat, &sin_lat_o, &cos_lat_o);
sinphi1 = sin_lat_o;
cosphi1 = cos_lat_o;
es = 1.0 - SQUARE(r_minor / r_major);
e = sqrt(es);
if(es < 0.00001)
{
ind = 1; /* sphere */
qp = 2.0;
q1 = 2.0;
}
else
{
ind = 0; /* ellipsoid */
qp = (1.0 - es)* (((1.0/(1.0 - es))-(1.0/(2.0*e))*log((1.0 - e)/(1.0 + e))));
if((fabs (lat_center - HALF_PI) <= EPSLN ) || (fabs (lat_center + HALF_PI) <= EPSLN ))
{
/* no other constants needed for LA with North and South polar Aspects lat_center = 90 or -90*/
}
else
{
tsincos(lat_center, &sinphi1, &cosphi1);
q1 = (1.0 - es) * ((sinphi1 / (1.0 - es * sinphi1 * sinphi1))
- (1.0 / (2.0 * e)) *
log((1.0 - e * sinphi1)/(1.0 + e * sinphi1)));
Rq = r_major * sqrt(qp/2.0);
if(fabs(q1) >= fabs(qp))
{
beta1 = HALF_PI * (fabs(q1/qp)/(q1/qp));
}
else
{
beta1 = asinz(q1/qp);
}
tsincos(beta1, &sin_beta1, &cos_beta1);
m1 = cosphi1 / sqrt(1.0 - es * sinphi1 * sinphi1);
D = (r_major * m1)/ (Rq * cos_beta1);
}
}
/* Report parameters to the user
-----------------------------*/
ptitle("LAMBERT AZIMUTHAL EQUAL-AREA");
radius2(r_major, r_minor);
cenlon(center_long);
cenlat(center_lat);
offsetp(false_easting,false_northing);
return(OK);
}
/**
* Get the diameter of the brush for certain pressure.
* @param pressure pen pressure
* @return diameter
* @post 0 < RESULT
*/
int Brush::diameter(qreal pressure) const
{
return qMax(0.5, interpolate(radius1(), radius2(), pressure))*2;
}
/* Initialize the Albers projection
-------------------------------*/
int alberinvint(
double r_maj, /* major axis */
double r_min, /* minor axis */
double lat1, /* first standard parallel */
double lat2, /* second standard parallel */
double lon0, /* center longitude */
double lat0, /* center lattitude */
double false_east, /* x offset in meters */
double false_north) /* y offset in meters */
{
double sin_po,cos_po; /* sine and cos values */
double con; /* temporary variable */
double temp; /* temporary variable */
double ms1; /* small m 1 */
double ms2; /* small m 2 */
double qs0; /* small q 0 */
double qs1; /* small q 1 */
double qs2; /* small q 2 */
false_easting = false_east;
false_northing = false_north;
lon_center = lon0;
if (fabs(lat1 + lat2) < EPSLN)
{
p_error("Equal latitudes for Standard Parallels on opposite sides of equator"
,"alber-invinit");
return(31);
}
r_major = r_maj;
r_minor = r_min;
temp = r_minor / r_major;
es = 1.0 - SQUARE(temp);
e3 = sqrt(es);
tsincos(lat1, &sin_po, &cos_po);
con = sin_po;
ms1 = msfnz(e3,sin_po,cos_po);
qs1 = qsfnz(e3,sin_po,cos_po);
tsincos(lat2,&sin_po,&cos_po);
ms2 = msfnz(e3,sin_po,cos_po);
qs2 = qsfnz(e3,sin_po,cos_po);
tsincos(lat0,&sin_po,&cos_po);
qs0 = qsfnz(e3,sin_po,cos_po);
if (fabs(lat1 - lat2) > EPSLN)
ns0 = (ms1 * ms1 - ms2 *ms2)/ (qs2 - qs1);
else
ns0 = con;
c = ms1 * ms1 + ns0 * qs1;
rh = r_major * sqrt(c - ns0 * qs0)/ns0;
/* Report parameters to the user
-----------------------------*/
ptitle("ALBERS CONICAL EQUAL-AREA");
radius2(r_major, r_minor);
stanparl(lat1,lat2);
cenlonmer(lon_center);
origin(lat0);
offsetp(false_easting,false_northing);
return(OK);
}
/**
* @brief Get the real radius for the given pressure
* @param pressure
* @return radius
* @pre 0 <= pressure <= 1
* @post 0.5 <= RESULT
*/
qreal Brush::fradius(qreal pressure) const
{
return qMax(0.5, interpolate(radius1(), radius2(), pressure));
}
/**
* Get the brush radius for certain pressure.
* @param pressure pen pressure
* @return radius
* @pre 0 <= pressure <= 1
* @post 0 <= RESULT
*/
int Brush::radius(qreal pressure) const
{
return qRound(interpolate(radius1(), radius2(), pressure));
}
/* Initialize the Lambert Conformal conic projection
------------------------------------------------*/
int lamccforint(
double r_maj, /* major axis */
double r_min, /* minor axis */
double lat1, /* first standard parallel */
double lat2, /* second standard parallel */
double c_lon, /* center longitude */
double c_lat, /* center latitude */
double false_east, /* x offset in meters */
double false_north) /* y offset in meters */
{
double sin_po; /* sin value */
double cos_po; /* cos value */
double con; /* temporary variable */
double ms1; /* small m 1 */
double ms2; /* small m 2 */
double temp; /* temporary variable */
double ts0; /* small t 0 */
double ts1; /* small t 1 */
double ts2; /* small t 2 */
r_major = r_maj;
r_minor = r_min;
false_northing = false_north;
false_easting = false_east;
/* Standard Parallels cannot be equal and on opposite sides of the equator
------------------------------------------------------------------------*/
if (fabs(lat1+lat2) < EPSLN)
{
p_error("Equal Latitiudes for St. Parallels on opposite sides of equator",
"lamcc-for");
return(41);
}
temp = r_minor / r_major;
es = 1.0 - SQUARE(temp);
e = sqrt(es);
center_lon = c_lon;
center_lat = c_lat;
tsincos(lat1,&sin_po,&cos_po);
con = sin_po;
ms1 = msfnz(e,sin_po,cos_po);
ts1 = tsfnz(e,lat1,sin_po);
tsincos(lat2,&sin_po,&cos_po);
ms2 = msfnz(e,sin_po,cos_po);
ts2 = tsfnz(e,lat2,sin_po);
sin_po = sin(center_lat);
ts0 = tsfnz(e,center_lat,sin_po);
if (fabs(lat1 - lat2) > EPSLN)
ns = log (ms1/ms2)/ log (ts1/ts2);
else
ns = con;
f0 = ms1 / (ns * pow(ts1,ns));
rh = r_major * f0 * pow(ts0,ns);
/* Report parameters to the user
-----------------------------*/
ptitle("LAMBERT CONFORMAL CONIC");
radius2(r_major, r_minor);
stanparl(lat1,lat2);
cenlonmer(center_lon);
origin(c_lat);
offsetp(false_easting,false_northing);
return(OK);
}
/* Initialize the Equidistant Conic projection
------------------------------------------*/
int eqconinvint(
double r_maj, /* major axis */
double r_min, /* minor axis */
double lat1, /* latitude of standard parallel*/
double lat2, /* latitude of standard parallel*/
double center_lon, /* center longitude */
double center_lat, /* center latitude */
double false_east, /* x offset in meters */
double false_north, /* y offset in meters */
long mode) /* which format is present A B */
{
double temp; /* temporary variable */
double sinphi,cosphi; /* sin and cos values */
double ms1,ms2;
double ml1,ml2;
/* Place parameters in static storage for common use
-------------------------------------------------*/
r_major = r_maj;
r_minor = r_min;
lon_center = center_lon;
false_northing = false_north;
false_easting = false_east;
temp = r_minor / r_major;
es = 1.0 - SQUARE(temp);
e = sqrt(es);
e0 = e0fn(es);
e1 = e1fn(es);
e2 = e2fn(es);
e3 = e3fn(es);
tsincos(lat1,&sinphi,&cosphi);
ms1 = msfnz(e,sinphi,cosphi);
ml1 = mlfn(e0, e1, e2, e3, lat1);
/* format B
---------*/
if (mode != 0)
{
if (fabs(lat1 + lat2) < EPSLN)
{
p_error("Standard Parallels on opposite sides of equator","eqcon-for");
return(81);
}
tsincos(lat2,&sinphi,&cosphi);
ms2 = msfnz(e,sinphi,cosphi);
ml2 = mlfn(e0, e1, e2, e3, lat2);
if (fabs(lat1 - lat2) >= EPSLN)
ns = (ms1 - ms2) / (ml2 - ml1);
else
ns = sinphi;
}
else
ns = sinphi;
g = ml1 + ms1/ns;
ml0 = mlfn(e0, e1, e2, e3, center_lat);
rh = r_major * (g - ml0);
/* Report parameters to the user
-----------------------------*/
if (mode != 0)
{
ptitle("EQUIDISTANT CONIC");
radius2(r_major, r_minor);
stanparl(lat1,lat2);
cenlonmer(lon_center);
origin(center_lat);
offsetp(false_easting,false_northing);
}
else
{
ptitle("EQUIDISTANT CONIC");
radius2(r_major, r_minor);
stparl1(lat1);
cenlonmer(lon_center);
origin(center_lat);
offsetp(false_easting,false_northing);
}
return(OK);
}
// From http://www.gamedev.net/community/forums/topic.asp?topic_id=467789 -
// intersection of cylinder with ray
void Foam::searchableCylinder::findLineAll
(
const point& start,
const point& end,
pointIndexHit& near,
pointIndexHit& far
) const
{
near.setMiss();
far.setMiss();
vector point1Start(start-point1_);
vector point2Start(start-point2_);
vector point1End(end-point1_);
// Quick rejection of complete vector outside endcaps
scalar s1 = point1Start&unitDir_;
scalar s2 = point1End&unitDir_;
if ((s1 < 0 && s2 < 0) || (s1 > magDir_ && s2 > magDir_))
{
return;
}
// Line as P = start+t*V where V is unit vector and t=[0..mag(end-start)]
vector V(end-start);
scalar magV = mag(V);
if (magV < ROOTVSMALL)
{
return;
}
V /= magV;
// We now get the nearest intersections to start. This can either be
// the intersection with the end plane or with the cylinder side.
// Get the two points (expressed in t) on the end planes. This is to
// clip any cylinder intersection against.
scalar tPoint1;
scalar tPoint2;
// Maintain the two intersections with the endcaps
scalar tNear = VGREAT;
scalar tFar = VGREAT;
{
scalar s = (V&unitDir_);
if (mag(s) > VSMALL)
{
tPoint1 = -s1/s;
tPoint2 = -(point2Start&unitDir_)/s;
if (tPoint2 < tPoint1)
{
Swap(tPoint1, tPoint2);
}
if (tPoint1 > magV || tPoint2 < 0)
{
return;
}
// See if the points on the endcaps are actually inside the cylinder
if (tPoint1 >= 0 && tPoint1 <= magV)
{
if (radius2(start+tPoint1*V) <= sqr(radius_))
{
tNear = tPoint1;
}
}
if (tPoint2 >= 0 && tPoint2 <= magV)
{
if (radius2(start+tPoint2*V) <= sqr(radius_))
{
// Check if already have a near hit from point1
if (tNear <= 1)
{
tFar = tPoint2;
}
else
{
tNear = tPoint2;
}
}
}
}
else
{
// Vector perpendicular to cylinder. Check for outside already done
// above so just set tpoint to allow all.
tPoint1 = -VGREAT;
tPoint2 = VGREAT;
}
}
const vector x = point1Start ^ unitDir_;
const vector y = V ^ unitDir_;
const scalar d = sqr(radius_);
// Second order equation of the form a*t^2 + b*t + c
const scalar a = (y&y);
const scalar b = 2*(x&y);
const scalar c = (x&x)-d;
const scalar disc = b*b-4*a*c;
scalar t1 = -VGREAT;
scalar t2 = VGREAT;
if (disc < 0)
{
// Fully outside
return;
}
else if (disc < ROOTVSMALL)
{
// Single solution
if (mag(a) > ROOTVSMALL)
{
t1 = -b/(2*a);
//Pout<< "single solution t:" << t1
// << " for start:" << start << " end:" << end
// << " c:" << c << endl;
if (t1 >= 0 && t1 <= magV && t1 >= tPoint1 && t1 <= tPoint2)
{
// valid. Insert sorted.
if (t1 < tNear)
{
tFar = tNear;
tNear = t1;
}
else if (t1 < tFar)
{
tFar = t1;
}
}
else
{
return;
}
}
else
{
// Aligned with axis. Check if outside radius
//Pout<< "small discriminant:" << disc
// << " for start:" << start << " end:" << end
// << " magV:" << magV
// << " c:" << c << endl;
if (c > 0)
{
return;
}
}
}
else
{
if (mag(a) > ROOTVSMALL)
{
scalar sqrtDisc = sqrt(disc);
t1 = (-b - sqrtDisc)/(2*a);
t2 = (-b + sqrtDisc)/(2*a);
if (t2 < t1)
{
Swap(t1, t2);
}
if (t1 >= 0 && t1 <= magV && t1 >= tPoint1 && t1 <= tPoint2)
{
// valid. Insert sorted.
if (t1 < tNear)
{
tFar = tNear;
tNear = t1;
}
else if (t1 < tFar)
{
tFar = t1;
}
}
if (t2 >= 0 && t2 <= magV && t2 >= tPoint1 && t2 <= tPoint2)
{
// valid. Insert sorted.
if (t2 < tNear)
{
tFar = tNear;
tNear = t2;
}
else if (t2 < tFar)
{
tFar = t2;
}
}
//Pout<< "two solutions t1:" << t1 << " t2:" << t2
// << " for start:" << start << " end:" << end
// << " magV:" << magV
// << " c:" << c << endl;
}
else
{
// Aligned with axis. Check if outside radius
//Pout<< "large discriminant:" << disc
// << " small a:" << a
// << " for start:" << start << " end:" << end
// << " magV:" << magV
// << " c:" << c << endl;
if (c > 0)
{
return;
}
}
}
// Check tNear, tFar
if (tNear >= 0 && tNear <= magV)
{
near.setPoint(start+tNear*V);
near.setHit();
near.setIndex(0);
if (tFar <= magV)
{
far.setPoint(start+tFar*V);
far.setHit();
far.setIndex(0);
}
}
else if (tFar >= 0 && tFar <= magV)
{
near.setPoint(start+tFar*V);
near.setHit();
near.setIndex(0);
}
}
