void test_wait_for_either_of_five_futures_1()
{
boost::packaged_task<int> pt(make_int_slowly);
boost::unique_future<int> f1(pt.get_future());
boost::packaged_task<int> pt2(make_int_slowly);
boost::unique_future<int> f2(pt2.get_future());
boost::packaged_task<int> pt3(make_int_slowly);
boost::unique_future<int> f3(pt3.get_future());
boost::packaged_task<int> pt4(make_int_slowly);
boost::unique_future<int> f4(pt4.get_future());
boost::packaged_task<int> pt5(make_int_slowly);
boost::unique_future<int> f5(pt5.get_future());
boost::thread(::cast_to_rval(pt));
unsigned const future=boost::wait_for_any(f1,f2,f3,f4,f5);
BOOST_CHECK(future==0);
BOOST_CHECK(f1.is_ready());
BOOST_CHECK(!f2.is_ready());
BOOST_CHECK(!f3.is_ready());
BOOST_CHECK(!f4.is_ready());
BOOST_CHECK(!f5.is_ready());
BOOST_CHECK(f1.get()==42);
}
TEST_F(CreatePolygonTreesTest, P0AndP1AndP2AndP3)
{
GeoLib::SimplePolygonTree *pt0(new GeoLib::SimplePolygonTree(_p0, nullptr));
GeoLib::SimplePolygonTree *pt1(new GeoLib::SimplePolygonTree(_p1, nullptr));
GeoLib::SimplePolygonTree *pt2(new GeoLib::SimplePolygonTree(_p2, nullptr));
GeoLib::SimplePolygonTree *pt3(new GeoLib::SimplePolygonTree(_p3, nullptr));
std::list<GeoLib::SimplePolygonTree*> pt_list;
pt_list.push_back(pt0);
pt_list.push_back(pt1);
pt_list.push_back(pt2);
pt_list.push_back(pt3);
ASSERT_EQ(4u, pt_list.size());
ASSERT_FALSE(_p0->isPolylineInPolygon(*_p1));
ASSERT_FALSE(_p0->isPolylineInPolygon(*_p2));
ASSERT_FALSE(_p1->isPolylineInPolygon(*_p0));
ASSERT_FALSE(_p1->isPolylineInPolygon(*_p2));
ASSERT_TRUE(_p2->isPolylineInPolygon(*_p0));
ASSERT_TRUE(_p2->isPolylineInPolygon(*_p1));
ASSERT_TRUE(_p2->isPolylineInPolygon(*_p3));
ASSERT_TRUE(_p1->isPolylineInPolygon(*_p3));
createPolygonTrees(pt_list);
ASSERT_EQ(1u, pt_list.size());
ASSERT_EQ(2u, (*(pt_list.begin()))->getNChildren());
std::for_each(pt_list.begin(), pt_list.end(), std::default_delete<GeoLib::SimplePolygonTree>());
}
void CPWL_CBButton::DrawThisAppearance(CFX_RenderDevice* pDevice,
CFX_Matrix* pUser2Device) {
CPWL_Wnd::DrawThisAppearance(pDevice, pUser2Device);
CFX_FloatRect rectWnd = CPWL_Wnd::GetWindowRect();
if (IsVisible() && !rectWnd.IsEmpty()) {
CFX_FloatPoint ptCenter = GetCenterPoint();
CFX_FloatPoint pt1(ptCenter.x - PWL_CBBUTTON_TRIANGLE_HALFLEN,
ptCenter.y + PWL_CBBUTTON_TRIANGLE_HALFLEN * 0.5f);
CFX_FloatPoint pt2(ptCenter.x + PWL_CBBUTTON_TRIANGLE_HALFLEN,
ptCenter.y + PWL_CBBUTTON_TRIANGLE_HALFLEN * 0.5f);
CFX_FloatPoint pt3(ptCenter.x,
ptCenter.y - PWL_CBBUTTON_TRIANGLE_HALFLEN * 0.5f);
if (IsFloatBigger(rectWnd.right - rectWnd.left,
PWL_CBBUTTON_TRIANGLE_HALFLEN * 2) &&
IsFloatBigger(rectWnd.top - rectWnd.bottom,
PWL_CBBUTTON_TRIANGLE_HALFLEN)) {
CFX_PathData path;
path.SetPointCount(4);
path.SetPoint(0, pt1.x, pt1.y, FXPT_MOVETO);
path.SetPoint(1, pt2.x, pt2.y, FXPT_LINETO);
path.SetPoint(2, pt3.x, pt3.y, FXPT_LINETO);
path.SetPoint(3, pt1.x, pt1.y, FXPT_LINETO);
pDevice->DrawPath(&path, pUser2Device, nullptr,
CPWL_Utils::PWLColorToFXColor(PWL_DEFAULT_BLACKCOLOR,
GetTransparency()),
0, FXFILL_ALTERNATE);
}
}
}
TopoDS_Shape CreateRectangle::executeCreation() const
{
try
{
gp_Pnt pt1(point);
gp_Pnt pt2(point.X() + width, point.Y(), point.Z());
gp_Pnt pt3(point.X() + width, point.Y() + height, point.Z());
gp_Pnt pt4(point.X(), point.Y() + height, point.Z());
Handle(Geom_TrimmedCurve) segment1 = GC_MakeSegment(pt1, pt2);
Handle(Geom_TrimmedCurve) segment2 = GC_MakeSegment(pt2, pt3);
Handle(Geom_TrimmedCurve) segment3 = GC_MakeSegment(pt3, pt4);
Handle(Geom_TrimmedCurve) segment4 = GC_MakeSegment(pt4, pt1);
TopoDS_Edge edge1 = BRepBuilderAPI_MakeEdge(segment1);
TopoDS_Edge edge2 = BRepBuilderAPI_MakeEdge(segment2);
TopoDS_Edge edge3 = BRepBuilderAPI_MakeEdge(segment3);
TopoDS_Edge edge4 = BRepBuilderAPI_MakeEdge(segment4);
TopoDS_Wire wire = BRepBuilderAPI_MakeWire(edge1 , edge2 , edge3, edge4);
BRepBuilderAPI_MakeFace makeFace(wire);
return makeFace.Shape();
}
catch(const StdFail_NotDone& ex)
{
throw Common::Exception(QObject::tr("Create rectangle error"));
}
}
void check_compare_y_at_x_left()
{
Polycurve_conic_traits_2 traits;
Polycurve_conic_traits_2::Construct_x_monotone_curve_2
construct_x_monotone_curve_2 = traits.construct_x_monotone_curve_2_object();
Polycurve_conic_traits_2::Compare_y_at_x_left_2 cmp_y_at_x_left_2 =
traits.compare_y_at_x_left_2_object();
//create constructing curves
Rat_point_2 ps2(1, 10);
Rat_point_2 pmid2(5, 4);
Rat_point_2 pt2(10, 1);
Conic_curve_2 c1(ps2, pmid2, pt2);
Rat_point_2 ps3(10, 1);
Rat_point_2 pmid3(5, 4);
Rat_point_2 pt3(1, 10);
Conic_curve_2 c2(ps3, pmid3, pt3);
//construct x-monotone curve(compatible with polyline class)
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 =
construct_x_monotone_curve_2(c1);
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc2 =
construct_x_monotone_curve_2(c2);
Polycurve_conic_traits_2::Point_2 intersection_point =
Polycurve_conic_traits_2::Point_2(5,4);
CGAL::Comparison_result result;
result = cmp_y_at_x_left_2(polyline_xmc1, polyline_xmc2, intersection_point);
std::cout << "Compare_y_at_x_left:: Expected Answer: equal, Computed answer: "
<< (result == CGAL::SMALLER ? "smaller":
(result == CGAL::LARGER ? "Larger" : "equal")) << std::endl;
}
void CPWL_CBButton::GetThisAppearanceStream(CFX_ByteTextBuf& sAppStream) {
CPWL_Wnd::GetThisAppearanceStream(sAppStream);
CFX_FloatRect rectWnd = CPWL_Wnd::GetWindowRect();
if (IsVisible() && !rectWnd.IsEmpty()) {
CFX_ByteTextBuf sButton;
CFX_FloatPoint ptCenter = GetCenterPoint();
CFX_FloatPoint pt1(ptCenter.x - PWL_CBBUTTON_TRIANGLE_HALFLEN,
ptCenter.y + PWL_CBBUTTON_TRIANGLE_HALFLEN * 0.5f);
CFX_FloatPoint pt2(ptCenter.x + PWL_CBBUTTON_TRIANGLE_HALFLEN,
ptCenter.y + PWL_CBBUTTON_TRIANGLE_HALFLEN * 0.5f);
CFX_FloatPoint pt3(ptCenter.x,
ptCenter.y - PWL_CBBUTTON_TRIANGLE_HALFLEN * 0.5f);
if (IsFloatBigger(rectWnd.right - rectWnd.left,
PWL_CBBUTTON_TRIANGLE_HALFLEN * 2) &&
IsFloatBigger(rectWnd.top - rectWnd.bottom,
PWL_CBBUTTON_TRIANGLE_HALFLEN)) {
sButton << "0 g\n";
sButton << pt1.x << " " << pt1.y << " m\n";
sButton << pt2.x << " " << pt2.y << " l\n";
sButton << pt3.x << " " << pt3.y << " l\n";
sButton << pt1.x << " " << pt1.y << " l f\n";
sAppStream << "q\n" << sButton << "Q\n";
}
}
}
void CPWL_CBButton::DrawThisAppearance(CFX_RenderDevice* pDevice,
CFX_Matrix* pUser2Device) {
CPWL_Wnd::DrawThisAppearance(pDevice, pUser2Device);
CFX_FloatRect rectWnd = CPWL_Wnd::GetWindowRect();
if (IsVisible() && !rectWnd.IsEmpty()) {
CFX_PointF ptCenter = GetCenterPoint();
CFX_PointF pt1(ptCenter.x - PWL_CBBUTTON_TRIANGLE_HALFLEN,
ptCenter.y + PWL_CBBUTTON_TRIANGLE_HALFLEN * 0.5f);
CFX_PointF pt2(ptCenter.x + PWL_CBBUTTON_TRIANGLE_HALFLEN,
ptCenter.y + PWL_CBBUTTON_TRIANGLE_HALFLEN * 0.5f);
CFX_PointF pt3(ptCenter.x,
ptCenter.y - PWL_CBBUTTON_TRIANGLE_HALFLEN * 0.5f);
if (IsFloatBigger(rectWnd.right - rectWnd.left,
PWL_CBBUTTON_TRIANGLE_HALFLEN * 2) &&
IsFloatBigger(rectWnd.top - rectWnd.bottom,
PWL_CBBUTTON_TRIANGLE_HALFLEN)) {
CFX_PathData path;
path.AppendPoint(pt1, FXPT_TYPE::MoveTo, false);
path.AppendPoint(pt2, FXPT_TYPE::LineTo, false);
path.AppendPoint(pt3, FXPT_TYPE::LineTo, false);
path.AppendPoint(pt1, FXPT_TYPE::LineTo, false);
pDevice->DrawPath(&path, pUser2Device, nullptr,
PWL_DEFAULT_BLACKCOLOR.ToFXColor(GetTransparency()), 0,
FXFILL_ALTERNATE);
}
}
}
void CybOBB::buildFromTriangles()
{
//Defining which mesh will be used.
cybMesh<cybSurfaceTriTraits>* mesh;
if(interatorBox) mesh = getInterator()->getMesh(getInterator()->getActiveMesh());
else mesh = CybParameters::getInstance()->mesh[layerOfCollision];
//Variable declarations.
cybSurfaceTriTraits::sCell* aux;
sVertex *ponto1, *ponto2, *ponto3;
CybVector3D<double> pt1, pt2, pt3;
CybVector3D<double> mu, mui;
CybVector3D<double> norm;
CybVector3D<double> covMatrix[3];
int qtdCells = mesh->getNumberOfCells();
double Ai, Am = 0.0;
double cxx = 0.0, cxy = 0.0, cxz = 0.0, cyy = 0.0, cyz = 0.0, czz = 0.0;
//Calculating the covariance terms.
for(int i = 0; i < qtdCells; ++i)
{
aux = mesh->getCell(i);
ponto1 = mesh->getVertex(aux->getVertexId(0));
ponto2 = mesh->getVertex(aux->getVertexId(1));
ponto3 = mesh->getVertex(aux->getVertexId(2));
pt1(ponto1->getCoord(0), ponto1->getCoord(1), ponto1->getCoord(2));
pt2(ponto2->getCoord(0), ponto2->getCoord(1), ponto2->getCoord(2));
pt3(ponto3->getCoord(0), ponto3->getCoord(1), ponto3->getCoord(2));
mui = (pt1 + pt2 + pt3)/3.0;
norm = (pt2 - pt1) * (pt3 - pt1);
Ai = norm.getNorm()/2.0;
mu = mu + (mui * Ai);
Am += Ai;
cxx += ( 9.0 * mui[0] * mui[0] + pt1[0] * pt1[0] + pt2[0] * pt2[0] + pt3[0] * pt3[0] ) * (Ai/12.0);
cxy += ( 9.0 * mui[0] * mui[1] + pt1[0] * pt1[1] + pt2[0] * pt2[1] + pt3[0] * pt3[1] ) * (Ai/12.0);
cxz += ( 9.0 * mui[0] * mui[2] + pt1[0] * pt1[2] + pt2[0] * pt2[2] + pt3[0] * pt3[2] ) * (Ai/12.0);
cyy += ( 9.0 * mui[1] * mui[1] + pt1[1] * pt1[1] + pt2[1] * pt2[1] + pt3[1] * pt3[1] ) * (Ai/12.0);
cyz += ( 9.0 * mui[1] * mui[2] + pt1[1] * pt1[2] + pt2[1] * pt2[2] + pt3[1] * pt3[2] ) * (Ai/12.0);
czz += ( 9.0 * mui[2] * mui[2] + pt1[2] * pt1[2] + pt2[2] * pt2[2] + pt3[2] * pt3[2] ) * (Ai/12.0);
}
//Dividing Am from mu and the covariance terms.
mu = mu / Am;
cxx /= Am; cxy /= Am; cxz /= Am; cyy /= Am; cyz /= Am; czz /= Am;
//Subtracting the E[X]*E[Y] terms.
cxx -= mu[0] * mu[0]; cxy -= mu[0] * mu[1]; cxz -= mu[0] * mu[2];
cyy -= mu[1] * mu[1]; cyz -= mu[1] * mu[2]; czz -= mu[2] * mu[2];
//Building the covariance matrix.
covMatrix[0](cxx, cxy, cxz);
covMatrix[1](cxy, cyy, cyz);
covMatrix[2](cxz, cyz, czz);
//Building OBB from the covariance matrix.
buildOBB(covMatrix, mesh);
}
TopoDS_Shape OCCPartFactory::makeCube( const Standard_Real width,
const Standard_Real height,
const Standard_Real depth)
{
// define points
gp_Pnt pt1( -width / 2.0, 0.0, 0.0 );
gp_Pnt pt2( -width / 2.0, -depth / 2.0, 0.0 );
gp_Pnt pt3( width / 2.0, -depth / 2.0, 0.0 );
gp_Pnt pt4( width /2.0, 0.0, 0.0 );
// define segments
Handle_Geom_TrimmedCurve seg1 = GC_MakeSegment( pt1, pt2 );
Handle_Geom_TrimmedCurve seg2 = GC_MakeSegment( pt2, pt3 );
Handle_Geom_TrimmedCurve seg3 = GC_MakeSegment( pt3, pt4 );
// make edge
TopoDS_Edge edge1 = BRepBuilderAPI_MakeEdge( seg1 );
TopoDS_Edge edge2 = BRepBuilderAPI_MakeEdge( seg2 );
TopoDS_Edge edge3 = BRepBuilderAPI_MakeEdge( seg3 );
// make wire
TopoDS_Wire wire1 = BRepBuilderAPI_MakeWire( edge1, edge2, edge3 );
//Complete Profile
gp_Ax1 xAxis = gp::OX();
gp_Trsf transfer;
transfer.SetMirror( xAxis );
BRepBuilderAPI_Transform aBRepTrsf( wire1 , transfer );
TopoDS_Shape mirroredShape = aBRepTrsf.Shape();
TopoDS_Wire mirroredWire1 = TopoDS::Wire( mirroredShape );
BRepBuilderAPI_MakeWire mkWire;
mkWire.Add( wire1 );
mkWire.Add( mirroredWire1 );
TopoDS_Wire wireProfile = mkWire.Wire();
//Body : Prism the Profile
TopoDS_Face faceProfile = BRepBuilderAPI_MakeFace( wireProfile );
gp_Vec prismVec( 0.0 , 0.0 , height );
TopoDS_Shape cube = BRepPrimAPI_MakePrism( faceProfile, prismVec);
// cube.setMaterial( Graphic3d_NOM_JADE );
// Handle_AIS_Shape shape = new AIS_Shape( cube );
// shape->SetColor( Quantity_NOC_RED );
// return shape;
return cube;
}
void quadrotor_job::calc_quadrotor()
{
// Rotation
cv::Mat proj_center_training = AT*quadrotor_affine::image_center_training;
double u = quadrotor_affine::image_center_query.at<double>(0) - proj_center_training.at<double>(0);
control.at<double>(0) = 0.0;
control.at<double>(1) = 0.0;
control.at<double>(2) = 0.0;
control.at<double>(0) = 0.0;
control.at<double>(3) = ctrl_gain*u;
double maxspeed1 = 0.5;
double maxspeed2 = 1;
control.at<double>(3) = (control.at<double>(3)>maxspeed1)? maxspeed1:control.at<double>(3);
control.at<double>(3) = (control.at<double>(3)<-maxspeed1)? -maxspeed1:control.at<double>(3);
/* std::cout<<"u = "<<u<<std::endl;
std::cout<<"image_center_query = "<<quadrotor_affine::image_center_query.at<double>(0)<<std::endl;
std::cout<<"proj_center_training = "<<quadrotor_affine::image_center_training<<std::endl;
std::cout<<"proj_center_training = "<<proj_center_training.at<double>(0)<<std::endl;;
std::cout<<"AT = "<<AT<<std::endl;*/
// Translation
double area = 0.0;
cv::Mat pt1(3,1, CV_64F), pt2(3,1, CV_64F), pt3(3,1, CV_64F);
//projecting bounding box
pt1.at<double>(0) = quadrotor_affine::Contour[0].x;
pt1.at<double>(1) = quadrotor_affine::Contour[0].y;
pt1.at<double>(2) = 1.0;
pt2.at<double>(0) = quadrotor_affine::Contour[1].x;
pt2.at<double>(1) = quadrotor_affine::Contour[1].y;
pt2.at<double>(2) = 1.0;
pt3.at<double>(0) = quadrotor_affine::Contour[2].x;
pt3.at<double>(1) = quadrotor_affine::Contour[2].y;
pt3.at<double>(2) = 1.0;
cv::Mat proj_pt1 = AT*pt1;
cv::Mat proj_pt2 = AT*pt2;
cv::Mat proj_pt3 = AT*pt3;
double width = sqrt((proj_pt2.at<double>(0) - proj_pt1.at<double>(0))*(proj_pt2.at<double>(0) - proj_pt1.at<double>(0)) + (proj_pt2.at<double>(1) - proj_pt1.at<double>(1))*(proj_pt2.at<double>(1) - proj_pt1.at<double>(1)));
double height = sqrt((proj_pt3.at<double>(0) - proj_pt2.at<double>(0))*(proj_pt3.at<double>(0) - proj_pt2.at<double>(0)) + (proj_pt3.at<double>(1) - proj_pt2.at<double>(1))*(proj_pt3.at<double>(1) - proj_pt2.at<double>(1)));
area = width*height;
/* std::cout<<"w"<<width<<std::endl;
std::cout<<"h"<<height<<std::endl;
std::cout<<"a"<<area<<std::endl;*/
//std::cout<<"a"<<area<<std::endl;
// std::cout<<"3: " <<proj_center_training<<std::endl;
control.at<double>(0) = ctrl_gain2*(ctrl_sweetspot - area)/ctrl_sweetspot;
//std::cout<<"4: " <<control.at<double>(0) <<std::endl;
control.at<double>(0) = (control.at<double>(0)>maxspeed2)? maxspeed2:control.at<double>(0);
control.at<double>(0) = (control.at<double>(0)<-maxspeed2)? -maxspeed2:control.at<double>(0);
}
void HelloScene::drawAfter()
{
SGraphic.drawLine(10, 10, 300, 300);
CBPoint pt1(100,50);
CBPoint pt2(125,50);
CBPoint pt3(125,75);
CBPoint pt4(100,75);
SGraphic.drawLineLoop(pt1, pt2, pt3, pt4);
CBRect rect(100,100,30,30);
SGraphic.drawRect(rect);
CBPoint pt5(200, 100);
SGraphic.drawCircle(pt5, 50);
}
void HelloScene::drawAfter()
{
SGraphic.drawLine(10, 10, 300, 300);
CBPoint pt1(200,100);
CBPoint pt2(250,100);
CBPoint pt3(250,150);
CBPoint pt4(200,150);
SGraphic.drawLineLoop(pt1, pt2, pt3, pt4);
CBRect rect(200,200,50,50);
SGraphic.drawRect(rect);
CBPoint pt5(400, 200);
SGraphic.drawCircle(pt5, 100);
}
void check_equal()
{
bool are_equal;
Polycurve_conic_traits_2 traits;
Polycurve_conic_traits_2::Equal_2 equal = traits.equal_2_object();
Polycurve_conic_traits_2::Construct_x_monotone_curve_2
construct_x_monotone_curve_2 = traits.construct_x_monotone_curve_2_object();
//create some curves
Conic_point_2 ps1(Rational(1,4), 4);
Conic_point_2 pt1(2, Rational(1,2));
Conic_curve_2 c1(0, 0, 1, 0, 0, -1, CGAL::COUNTERCLOCKWISE, ps1, pt1);
Conic_point_2 ps2(Rational(1,4), 4);
Conic_point_2 pt2(2, Rational(1,2));
Conic_curve_2 c2(0, 0, 1, 0, 0, -1, CGAL::COUNTERCLOCKWISE, ps2, pt2);
Rat_point_2 ps3(Rational(1,4), 4);
Rat_point_2 pmid3(Rational(3,2), 2);
Rat_point_2 pt3(2, Rational(1,3));
Conic_curve_2 c3(ps3, pmid3, pt3);
Rat_point_2 ps4(1, 5);
Rat_point_2 pmid4(Rational(3,2), 3);
Rat_point_2 pt4(3, Rational(1,3));
Conic_curve_2 c4(ps4, pmid4, pt4);
// //make x_monotone
Polycurve_conic_traits_2::X_monotone_curve_2 xmc1 =
construct_x_monotone_curve_2(c1);
Polycurve_conic_traits_2::X_monotone_curve_2 xmc2 =
construct_x_monotone_curve_2(c2);
Polycurve_conic_traits_2::X_monotone_curve_2 xmc3 =
construct_x_monotone_curve_2(c3);
Polycurve_conic_traits_2::X_monotone_curve_2 xmc4 =
construct_x_monotone_curve_2(c4);
are_equal = equal(xmc1, xmc2);
std::cout << "Two equal conic arcs are computed as: "
<< ((are_equal) ? "equal" : "Not equal") << std::endl;
are_equal = equal(xmc3, xmc2);
std::cout << "Two un-equal conic arcs are computed as: "
<< ((are_equal) ? "equal" : "Not equal") << std::endl;
are_equal = equal(xmc3, xmc4);
std::cout << "Two un-equal conic arcs are computed as: "
<< ((are_equal) ? "equal" : "Not equal") << std::endl;
}
double QgsCircularString::closestPointOnArc( double x1, double y1, double x2, double y2, double x3, double y3,
const QgsPoint &pt, QgsPoint &segmentPt, QgsVertexId &vertexAfter, bool *leftOf, double epsilon )
{
double radius, centerX, centerY;
QgsPoint pt1( x1, y1 );
QgsPoint pt2( x2, y2 );
QgsPoint pt3( x3, y3 );
QgsGeometryUtils::circleCenterRadius( pt1, pt2, pt3, radius, centerX, centerY );
double angle = QgsGeometryUtils::ccwAngle( pt.y() - centerY, pt.x() - centerX );
double angle1 = QgsGeometryUtils::ccwAngle( pt1.y() - centerY, pt1.x() - centerX );
double angle2 = QgsGeometryUtils::ccwAngle( pt2.y() - centerY, pt2.x() - centerX );
double angle3 = QgsGeometryUtils::ccwAngle( pt3.y() - centerY, pt3.x() - centerX );
bool clockwise = QgsGeometryUtils::circleClockwise( angle1, angle2, angle3 );
if ( QgsGeometryUtils::angleOnCircle( angle, angle1, angle2, angle3 ) )
{
//get point on line center -> pt with distance radius
segmentPt = QgsGeometryUtils::pointOnLineWithDistance( QgsPoint( centerX, centerY ), pt, radius );
//vertexAfter
vertexAfter.vertex = QgsGeometryUtils::circleAngleBetween( angle, angle1, angle2, clockwise ) ? 1 : 2;
}
else
{
double distPtPt1 = QgsGeometryUtils::sqrDistance2D( pt, pt1 );
double distPtPt3 = QgsGeometryUtils::sqrDistance2D( pt, pt3 );
segmentPt = ( distPtPt1 <= distPtPt3 ) ? pt1 : pt3;
vertexAfter.vertex = ( distPtPt1 <= distPtPt3 ) ? 1 : 2;
}
double sqrDistance = QgsGeometryUtils::sqrDistance2D( segmentPt, pt );
//prevent rounding errors if the point is directly on the segment
if ( qgsDoubleNear( sqrDistance, 0.0, epsilon ) )
{
segmentPt.setX( pt.x() );
segmentPt.setY( pt.y() );
sqrDistance = 0.0;
}
if ( leftOf )
{
double sqrDistancePointToCenter = ( pt.x() - centerX ) * ( pt.x() - centerX ) + ( pt.y() - centerY ) * ( pt.y() - centerY );
*leftOf = clockwise ? sqrDistancePointToCenter > radius * radius : sqrDistancePointToCenter < radius * radius;
}
return sqrDistance;
}
main()
{
page pg;
pg.adjustparams = adjust;
xy pt1(-7,4), pt2(0,0), pt3(-7,-4), pt4(8,0);
FeynDiagram fdA(pg,1,4,5.5);
line_plain L1A(fdA,pt1,pt2), L2A(fdA,pt2,pt3);
line_zigzag L3A(fdA,pt2,pt4);
FeynDiagram fdB(pg,4.5,7.5,5.5);
line_plain L1B(fdB,pt1,pt2), L2B(fdB,pt2,pt3);
line_wiggle L3B(fdB,pt2,pt4);
pg.output();
return 0;
}
QgsTriangle::QgsTriangle( const QPointF p1, const QPointF p2, const QPointF p3 )
{
mWkbType = QgsWkbTypes::Triangle;
QgsPoint pt1( p1 );
QgsPoint pt2( p2 );
QgsPoint pt3( p3 );
if ( !validateGeom( pt1, pt2, pt3 ) )
{
return;
}
QVector< double > x;
x << p1.x() << p2.x() << p3.x();
QVector< double > y;
y << p1.y() << p2.y() << p3.y();
QgsLineString *ext = new QgsLineString( x, y );
setExteriorRing( ext );
}
void test_wait_for_either_of_three_futures_3()
{
boost::packaged_task<int> pt(make_int_slowly);
boost::unique_future<int> f1(pt.get_future());
boost::packaged_task<int> pt2(make_int_slowly);
boost::unique_future<int> f2(pt2.get_future());
boost::packaged_task<int> pt3(make_int_slowly);
boost::unique_future<int> f3(pt3.get_future());
boost::thread(::cast_to_rval(pt3));
unsigned const future=boost::wait_for_any(f1,f2,f3);
BOOST_CHECK(future==2);
BOOST_CHECK(!f1.is_ready());
BOOST_CHECK(!f2.is_ready());
BOOST_CHECK(f3.is_ready());
BOOST_CHECK(f3.get()==42);
}
void CGuideRectODL::GetTopPointList( std::vector<gp_Pnt>& arrPoint )
{
m_arrTopPoint.clear();
//如果开始点大于结束点
Gdiplus::REAL fX0 = m_rtArea.GetLeft();
Gdiplus::REAL fY0 = m_rtArea.GetTop();
Gdiplus::REAL fX1 = m_rtArea.GetRight();
Gdiplus::REAL fY1 = m_rtArea.GetBottom();
gp_Pnt pt0(fX0, 0, fY0);
gp_Pnt pt1(fX1, 0, fY0);
gp_Pnt pt2(fX1, 0, fY1);
gp_Pnt pt3(fX0, 0, fY1);
m_arrTopPoint.push_back(pt0);
m_arrTopPoint.push_back(pt1);
m_arrTopPoint.push_back(pt2);
m_arrTopPoint.push_back(pt3);
m_arrTopPoint.push_back(pt0);
arrPoint = m_arrTopPoint;
}
void mark(cv::Mat& img, PPoint2d &p, unsigned char l) {
int r = 10;
//draw_circle(img, p, r, l);
// draw_circle(img, p[0], p[1], 10, l);
// draw_line(img, p[0]-r/2, p[1]-r/2, p[0]+r/2, p[1]+r/2, l);
// draw_line(img, p[0]-r/2, p[1]+r/2, p[0]+r/2, p[1]-r/2, l);
double x = p.x();
double y = p.y();
cv::Point2d pt(x,y);
cv::Point2d pt1(x - r / 2, y - r / 2);
cv::Point2d pt2(x + r / 2, y + r / 2);
cv::Point2d pt3(x - r / 2, y + r / 2);
cv::Point2d pt4(x + r / 2, y - r / 2);
cout << p << endl;
if (x >= 0 && y >= 0 && x <= img.rows && y <= img.cols) {
cv::circle(img, pt, 10, l);
cv::line(img, pt1, pt2, l);
cv::line(img, pt3, pt4, l);
}
}
void check_are_mergable()
{
Polycurve_conic_traits_2 traits;
Polycurve_conic_traits_2::Construct_x_monotone_curve_2
construct_x_monotone_curve_2 = traits.construct_x_monotone_curve_2_object();
Polycurve_conic_traits_2::Are_mergeable_2 are_mergeable_2 =
traits.are_mergeable_2_object();
//create a curve
Rat_point_2 ps1(1, 10);
Rat_point_2 pmid1(5, 4);
Rat_point_2 pt1(10, 1);
Conic_curve_2 c1(ps1, pmid1, pt1);
Rat_point_2 ps2(10, 1);
Rat_point_2 pmid2(15, 14);
Rat_point_2 pt2(20, 20);
Conic_curve_2 c2(ps2, pmid2, pt2);
Rat_point_2 ps3(Rational(1,4), 4);
Rat_point_2 pmid3(Rational(3,2), 2);
Rat_point_2 pt3(2, Rational(1,3));
Conic_curve_2 c3(ps3, pmid3, pt3);
//construct x-monotone curve(compatible with polyline class)
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc1 =
construct_x_monotone_curve_2(c1);
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc2 =
construct_x_monotone_curve_2(c2);
Polycurve_conic_traits_2::X_monotone_curve_2 polyline_xmc3 =
construct_x_monotone_curve_2(c3);
bool result = are_mergeable_2(polyline_xmc1, polyline_xmc2);
std::cout << "Are_mergable:: Mergable x-monotone polycurves are Computed as: "
<< ((result)? "Mergable" : "Not-Mergable") << std::endl;
result = are_mergeable_2(polyline_xmc1, polyline_xmc3);
std::cout << "Are_mergable:: Non-Mergable x-monotone polycurves are Computed as: "
<< ((result)? "Mergable" : "Not-Mergable") << std::endl;
}
void DrawResult(IplImage* image, windage::Matrix3 homography, CvScalar color = CV_RGB(255, 0, 0), int thickness = 1)
{
windage::Vector3 pt1(0.0, 0.0, 1.0);
windage::Vector3 pt2(TEMPLATE_WIDTH, 0.0, 1.0);
windage::Vector3 pt3(TEMPLATE_WIDTH, TEMPLATE_HEIGHT, 1.0);
windage::Vector3 pt4(0.0, TEMPLATE_HEIGHT, 1.0);
windage::Vector3 outPoint1 = homography * pt1;
windage::Vector3 outPoint2 = homography * pt2;
windage::Vector3 outPoint3 = homography * pt3;
windage::Vector3 outPoint4 = homography * pt4;
outPoint1 /= outPoint1.z;
outPoint2 /= outPoint2.z;
outPoint3 /= outPoint3.z;
outPoint4 /= outPoint4.z;
cvLine(image, cvPoint((int)outPoint1.x, (int)outPoint1.y), cvPoint((int)outPoint2.x, (int)outPoint2.y), color, thickness);
cvLine(image, cvPoint((int)outPoint2.x, (int)outPoint2.y), cvPoint((int)outPoint3.x, (int)outPoint3.y), color, thickness);
cvLine(image, cvPoint((int)outPoint3.x, (int)outPoint3.y), cvPoint((int)outPoint4.x, (int)outPoint4.y), color, thickness);
cvLine(image, cvPoint((int)outPoint4.x, (int)outPoint4.y), cvPoint((int)outPoint1.x, (int)outPoint1.y), color, thickness);
}
TEST(NumLib, SpatialFunctionInterpolationSurface)
{
// create geometry
GeoLib::Point pt1(0.0, 0.0, 0.0);
GeoLib::Point pt2(10.0, 0.0, 0.0);
GeoLib::Point pt3(10.0, 10.0, 0.0);
GeoLib::Point pt4(0.0, 10.0, 0.0);
std::vector<GeoLib::Point*> pnts = {&pt1, &pt2, &pt3, &pt4};
GeoLib::Polyline ply0(pnts);
ply0.addPoint(0);
ply0.addPoint(1);
ply0.addPoint(2);
ply0.addPoint(3);
ply0.addPoint(0);
std::unique_ptr<GeoLib::Surface> sfc1(GeoLib::Surface::createSurface(ply0));
// define a function
const std::vector<std::size_t> vec_point_ids = {{0, 1, 2, 3}};
const std::vector<double> vec_point_values = {{0., 100., 100., 0.}};
NumLib::LinearInterpolationOnSurface interpolate(*sfc1, vec_point_ids, vec_point_values, std::numeric_limits<double>::max());
// normal
for (unsigned k=0; k<10; k++) {
ASSERT_DOUBLE_EQ(k*10., interpolate(GeoLib::Point(k,0,0)));
ASSERT_DOUBLE_EQ(k*10., interpolate(GeoLib::Point(k,5,0)));
ASSERT_DOUBLE_EQ(k*10., interpolate(GeoLib::Point(k,10,0)));
}
// failure
// x, y
ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(-1,-1,0)));
ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(11,-1,0)));
ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(11,11,0)));
ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(-1,11,0)));
// z
ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(0,0,1)));
ASSERT_DOUBLE_EQ(std::numeric_limits<double>::max(), interpolate(GeoLib::Point(0,0,-1)));
}
void BlockingInfoRenderer::render(Camera* cam, Layer* layer, RenderList& instances) {
CellGrid* cg = layer->getCellGrid();
if (!cg) {
FL_WARN(_log, "No cellgrid assigned to layer, cannot draw grid");
return;
}
Rect cv = cam->getViewPort();
RenderList::const_iterator instance_it = instances.begin();
for (;instance_it != instances.end(); ++instance_it) {
Instance* instance = (*instance_it)->instance;
if (!instance->getObject()->isBlocking() || !instance->isBlocking()) {
continue;
}
std::vector<ExactModelCoordinate> vertices;
cg->getVertices(vertices, instance->getLocationRef().getLayerCoordinates());
std::vector<ExactModelCoordinate>::const_iterator it = vertices.begin();
int halfind = vertices.size() / 2;
ScreenPoint firstpt = cam->toScreenCoordinates(cg->toMapCoordinates(*it));
Point pt1(firstpt.x, firstpt.y);
Point pt2;
++it;
for (; it != vertices.end(); it++) {
ScreenPoint pts = cam->toScreenCoordinates(cg->toMapCoordinates(*it));
pt2.x = pts.x; pt2.y = pts.y;
Point cpt1 = pt1;
Point cpt2 = pt2;
m_renderbackend->drawLine(cpt1, cpt2, m_color.r, m_color.g, m_color.b);
pt1 = pt2;
}
m_renderbackend->drawLine(pt2, Point(firstpt.x, firstpt.y), m_color.r, m_color.g, m_color.b);
ScreenPoint spt1 = cam->toScreenCoordinates(cg->toMapCoordinates(vertices[0]));
Point pt3(spt1.x, spt1.y);
ScreenPoint spt2 = cam->toScreenCoordinates(cg->toMapCoordinates(vertices[halfind]));
Point pt4(spt2.x, spt2.y);
m_renderbackend->drawLine(pt3, pt4, m_color.r, m_color.g, m_color.b);
}
}
static void
test_lt ()
{
rw_info (0, __FILE__, __LINE__, "operator<");
std::tuple<> nt1, nt2;
TEST (!(nt1 < nt1));
TEST (!(nt1 < nt2));
std::tuple<int> it1 (1), it2 (2);
TEST (!(it1 < it1));
TEST (it1 < it2);
UserDefined ud1 (1), ud2 (2);
std::tuple<UserDefined> ut1 (ud1), ut2 (ud2);
TEST (!(ut1 < ut1));
TEST (ut1 < ut2);
std::tuple<long, const char*> pt1 (1234L, "string");
TEST (!(pt1 < pt1));
std::tuple<long, const char*> pt2 (1235L, "string");
TEST (pt1 < pt2);
std::tuple<long, const char*> pt3 (1234L, "strings");
TEST (pt1 < pt3);
std::tuple<bool, char, int, double, void*, UserDefined>
bt1 (true, 'a', 255, 3.14159, &nt1, ud1),
bt2 (true, 'a', 256, 3.14159, &nt1, ud1),
bt3 (true, 'a', 255, 3.14159, &nt1, ud2);
rw_assert (!(bt1 < bt1), __FILE__, __LINE__,
"bt1 < bt1, got true, expected false");
rw_assert (bt1 < bt2, __FILE__, __LINE__,
"bt1 < bt2, got false, expected true");
rw_assert (bt1 < bt3, __FILE__, __LINE__,
"bt1 < bt3, got false, expected true");
}
Cube::Cube(){
geoType = CUBE_GEO;
p = new Poly();
Point pt1(0,0,0);
Point pt2(0,0,10);
Point pt3(10,0,10);
Point pt4(10,0,0);
Point pt5(10,10,0);
Point pt6(10,10,10);
Point pt7(0,10,10);
Point pt8(0,10,0);
p->addFace(pt1, pt2, pt7, pt8); // bottom
p->addFace(pt3, pt4, pt5, pt6); // right
p->addFace(pt1, pt2, pt3, pt4); // front
p->addFace(pt5, pt6, pt7, pt8); // top
p->addFace(pt1, pt4, pt5, pt8); // left
p->addFace(pt2, pt3, pt6, pt7); // back
p->computeNormals();
this->addPoly(p); // this adds it to scene
p->bound();
this->bound();
}
int
main (int argc, char **argv)
{
random_update ();
#define HMAC(k, m) \
do { \
u_char digest[sha1::hashsize]; \
sha1_hmac (digest, k, sizeof (k) - 1, m, sizeof (m) - 1); \
warn << "k = " << k << "\nm = " << m << "\n" \
<< hexdump (digest, sizeof (digest)) << "\n"; \
} while (0)
#define HMAC2(k, k2, m) \
do { \
u_char digest[sha1::hashsize]; \
sha1_hmac_2 (digest, k, sizeof (k) - 1, k2, sizeof (k2) - 1, \
m, sizeof (m) - 1); \
warn << "k = " << k << "\nm = " << m << "\n" \
<< hexdump (digest, sizeof (digest)) << "\n"; \
} while (0)
#if 0
HMAC ("Jefe", "what do ya want for nothing?");
HMAC ("\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014\014", "Test With Truncation");
//HMAC2 ("Je", "fe", "what do ya want for nothing?");
#endif
bigint p ("c81698301db5fdba3c5fecfdd97ca952c1f0df3500740a567ecdb561555c8a34d0affcc99ae7a38b42d144373ae2f68b48064373b5baef7d25782fd07dc4b35f", 16);
bigint q ("d32d977062a62dccfc4a37a21b03fca098973b72860002a3c05084060fbaa81b5c0fc636902a2959fb5ffd3d8a4969fbe9e15037c35477c9789da0b74ef32e3f", 16);
bigint n ("a50e41c593b3b866bc4c72d0476611baab9bd54a22c62e11f536f87861ce592e7a101aea8652d3b949e66271b4497f91a861404eb5f3cba23f22b9b46fadda6cd327e3773eb23795e73ee06c16e5df18cf12e812fcd1bdbf3a4d7cca4fecd95fcbf248ac0534a3ebc67ebb06f9ca77d3ce1a5c4920da6d211b5f242e80d03661", 16);
rsa_pub rsapub (n);
str m ("a random string");
bigint c = rsapub.encrypt (m);
rsa_priv rsapriv (p, q);
m = rsapriv.decrypt (c, m.len ());
warn << "m " << m << "\n";
rsa_priv x (rsa_keygen (1024));
bigint pt (random_bigint (1019));
bigint ct, pt2;
BENCH (100000, ct = x.encrypt (pt));
BENCH (1000, pt = x.decrypt (ct));
#if 0
warn << pt.getstr (10) << "\n";
ct = x.encrypt (pt);
warn << ct.getstr (10) << "\n";;
pt2 = x.decrypt (ct);
warn << pt2.getstr (10) << "\n";
#endif
rabin_priv xx (rabin_keygen (1280, 2));
str pt3 ("plaintext message");
BENCH (100000, ct = xx.encrypt (pt3));
BENCH (1000, pt3 = xx.decrypt (ct, sizeof (pt3)));
#if 0
BENCH (100, ct = x.sign (pt3));
BENCH (1000, x.verify (pt3, ct));
BENCH (1000, ct = x.encrypt (pt3));
#endif
return 0;
}
bool QgsEllipseSymbolLayerV2::writeDxf( QgsDxfExport& e, double mmMapUnitScaleFactor, const QString& layerName, const QgsSymbolV2RenderContext* context, const QgsFeature* f, const QPointF& shift ) const
{
//width
double symbolWidth = mSymbolWidth;
QgsExpression* widthExpression = expression( "width" );
if ( widthExpression ) //1. priority: data defined setting on symbol layer level
{
symbolWidth = widthExpression->evaluate( const_cast<QgsFeature*>( f ) ).toDouble();
}
else if ( context->renderHints() & QgsSymbolV2::DataDefinedSizeScale ) //2. priority: is data defined size on symbol level
{
symbolWidth = mSize;
}
if ( mSymbolWidthUnit == QgsSymbolV2::MM )
{
symbolWidth *= mmMapUnitScaleFactor;
}
//height
double symbolHeight = mSymbolHeight;
QgsExpression* heightExpression = expression( "height" );
if ( heightExpression ) //1. priority: data defined setting on symbol layer level
{
symbolHeight = heightExpression->evaluate( const_cast<QgsFeature*>( f ) ).toDouble();
}
else if ( context->renderHints() & QgsSymbolV2::DataDefinedSizeScale ) //2. priority: is data defined size on symbol level
{
symbolHeight = mSize;
}
if ( mSymbolHeightUnit == QgsSymbolV2::MM )
{
symbolHeight *= mmMapUnitScaleFactor;
}
//outline width
double outlineWidth = mOutlineWidth;
QgsExpression* outlineWidthExpression = expression( "outline_width" );
if ( outlineWidthExpression )
{
outlineWidth = outlineWidthExpression->evaluate( const_cast<QgsFeature*>( context->feature() ) ).toDouble();
}
if ( mOutlineWidthUnit == QgsSymbolV2::MM )
{
outlineWidth *= outlineWidth;
}
//color
QColor c = mFillColor;
QgsExpression* fillColorExpression = expression( "fill_color" );
if ( fillColorExpression )
{
c = QColor( fillColorExpression->evaluate( const_cast<QgsFeature*>( context->feature() ) ).toString() );
}
int colorIndex = e.closestColorMatch( c.rgb() );
//symbol name
QString symbolName = mSymbolName;
QgsExpression* symbolNameExpression = expression( "symbol_name" );
if ( symbolNameExpression )
{
QgsExpression* symbolNameExpression = expression( "symbol_name" );
symbolName = symbolNameExpression->evaluate( const_cast<QgsFeature*>( context->feature() ) ).toString();
}
//offset
double offsetX = 0;
double offsetY = 0;
markerOffset( *context, offsetX, offsetY );
QPointF off( offsetX, offsetY );
//priority for rotation: 1. data defined symbol level, 2. symbol layer rotation (mAngle)
double rotation = 0.0;
QgsExpression* rotationExpression = expression( "rotation" );
if ( rotationExpression )
{
rotation = rotationExpression->evaluate( const_cast<QgsFeature*>( context->feature() ) ).toDouble();
}
else if ( !qgsDoubleNear( mAngle, 0.0 ) )
{
rotation = mAngle;
}
rotation = -rotation; //rotation in Qt is counterclockwise
if ( rotation )
off = _rotatedOffset( off, rotation );
QTransform t;
t.translate( shift.x() + offsetX, shift.y() + offsetY );
if ( rotation != 0 )
t.rotate( rotation );
double halfWidth = symbolWidth / 2.0;
double halfHeight = symbolHeight / 2.0;
if ( symbolName == "circle" )
{
//soon...
}
else if ( symbolName == "rectangle" )
{
QPointF pt1( t.map( QPointF( -halfWidth, -halfHeight ) ) );
QPointF pt2( t.map( QPointF( halfWidth, -halfHeight ) ) );
QPointF pt3( t.map( QPointF( -halfWidth, halfHeight ) ) );
QPointF pt4( t.map( QPointF( halfWidth, halfHeight ) ) );
e.writeSolid( layerName, colorIndex, QgsPoint( pt1.x(), pt1.y() ), QgsPoint( pt2.x(), pt2.y() ), QgsPoint( pt3.x(), pt3.y() ), QgsPoint( pt4.x(), pt4.y() ) );
return true;
}
else if ( symbolName == "cross" )
{
QgsPolyline line1( 2 );
QPointF pt1( t.map( QPointF( -halfWidth, 0 ) ) );
QPointF pt2( t.map( QPointF( halfWidth, 0 ) ) );
line1[0] = QgsPoint( pt1.x(), pt1.y() );
line1[1] = QgsPoint( pt2.x(), pt2.y() );
e.writePolyline( line1, layerName, "CONTINUOUS", colorIndex, outlineWidth, false );
QgsPolyline line2( 2 );
QPointF pt3( t.map( QPointF( 0, halfHeight ) ) );
QPointF pt4( t.map( QPointF( 0, -halfHeight ) ) );
line2[0] = QgsPoint( pt3.x(), pt3.y() );
line2[1] = QgsPoint( pt3.x(), pt3.y() );
e.writePolyline( line2, layerName, "CONTINUOUS", colorIndex, outlineWidth, false );
return true;
}
else if ( symbolName == "triangle" )
{
QPointF pt1( t.map( QPointF( -halfWidth, -halfHeight ) ) );
QPointF pt2( t.map( QPointF( halfWidth, -halfHeight ) ) );
QPointF pt3( t.map( QPointF( 0, halfHeight ) ) );
QPointF pt4( t.map( QPointF( 0, halfHeight ) ) );
e.writeSolid( layerName, colorIndex, QgsPoint( pt1.x(), pt1.y() ), QgsPoint( pt2.x(), pt2.y() ), QgsPoint( pt3.x(), pt3.y() ), QgsPoint( pt4.x(), pt4.y() ) );
return true;
}
return false; //soon...
}
QBezier QBezier::mapBy(const QTransform &transform) const
{
return QBezier::fromPoints(transform.map(pt1()), transform.map(pt2()), transform.map(pt3()), transform.map(pt4()));
}
int main( int nArgc, char ** papszArgv )
{
// register drivers
GDALAllRegister();
if( nArgc < 2 )
return EXIT_FAILURE;
double dfaCornersX[5] = {0};
double dfaCornersY[5] = {0};
CPLString sFileName;
// parse input values
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg],"-nw"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[1] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[1] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-ne"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[2] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[2] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-se"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[3] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[3] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-sw"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[4] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[4] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-c"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[0] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[0] = CPLAtofM(pszCoord);
}
else if(sFileName.empty())
sFileName = papszArgv[iArg];
}
OGRSpatialReference oOGRSpatialReference(SRS_WKT_WGS84);
int nZoneNo = ceil( (180.0 + dfaCornersX[0]) / 6.0 );
OGRSpatialReference oDstSpatialReference(SRS_WKT_WGS84);
oDstSpatialReference.SetUTM(nZoneNo, dfaCornersY[0] > 0);
// transform coordinates from WGS84 to UTM
OGRCoordinateTransformation *poCT = OGRCreateCoordinateTransformation( &oOGRSpatialReference, &oDstSpatialReference);
if(!poCT)
{
Usage("get coordinate transformation failed");
return EXIT_FAILURE;
}
int nResult = poCT->Transform(5, dfaCornersX, dfaCornersY, NULL);
if(!nResult)
{
Usage("transformation failed");
return EXIT_FAILURE;
}
// open input dataset
GDALDataset *poSrcDataset = (GDALDataset *) GDALOpen( sFileName, GA_ReadOnly ); // GA_Update
char* pszSpaRefDef = NULL;
if( oDstSpatialReference.exportToWkt(&pszSpaRefDef) != OGRERR_NONE)
{
CPLFree( pszSpaRefDef );
GDALClose( (GDALDatasetH) poSrcDataset );
return EXIT_FAILURE;
}
// search point along image
// add GCP to opened raster
OGRPoint ptCenter(dfaCornersX[0], dfaCornersY[0]);
OGRPoint pt1(dfaCornersX[1], dfaCornersY[1]); // NW Cormer
OGRPoint pt2(dfaCornersX[2], dfaCornersY[2]); // NE Corner
OGRPoint pt3(dfaCornersX[3], dfaCornersY[3]); // SE Corner
OGRPoint pt4(dfaCornersX[4], dfaCornersY[4]); // SW Corner
int nGCPCount = 0;
OGREnvelope DstEnv;
GDAL_GCP *paGSPs = PrepareGCP(sFileName, &pt1, &pt2, &pt3, &pt4, &ptCenter, oDstSpatialReference, poSrcDataset->GetRasterXSize(), poSrcDataset->GetRasterYSize(), nGCPCount, DstEnv);
if(poSrcDataset->SetGCPs(nGCPCount, paGSPs, pszSpaRefDef) != CE_None)
{
Usage( "Set GCPs failed" );
return EXIT_FAILURE;
}
// create warper
char **papszTO = NULL;
papszTO = CSLSetNameValue( papszTO, "METHOD", "GCP_TPS" );
papszTO = CSLSetNameValue( papszTO, "NUM_THREADS", "4" );
papszTO = CSLSetNameValue( papszTO, "DST_SRS", pszSpaRefDef );
papszTO = CSLSetNameValue( papszTO, "SRC_SRS", pszSpaRefDef );
papszTO = CSLSetNameValue( papszTO, "INSERT_CENTER_LONG", "FALSE" );
GDALDriver *poOutputDriver = (GDALDriver *) GDALGetDriverByName( "GTiff" );
CPLSetConfigOption( "CHECK_WITH_INVERT_PROJ", "TRUE" );
void* hTransformArg = GDALCreateGenImgProjTransformer2( poSrcDataset, NULL, papszTO );
GDALTransformerInfo* psInfo = (GDALTransformerInfo*)hTransformArg;
double adfThisGeoTransform[6];
double adfExtent[4];
int nThisPixels, nThisLines;
// suggest the raster output size
if( GDALSuggestedWarpOutput2( poSrcDataset, psInfo->pfnTransform, hTransformArg, adfThisGeoTransform, &nThisPixels, &nThisLines, adfExtent, 0 ) != CE_None )
{
Usage( "Suggest Output failed" );
return EXIT_FAILURE;
}
adfThisGeoTransform[0] = DstEnv.MinX;
adfThisGeoTransform[3] = DstEnv.MaxY;
int nPixels = (int) ((DstEnv.MaxX - DstEnv.MinX) / adfThisGeoTransform[1] + 0.5);
int nLines = (int) ((DstEnv.MaxY - DstEnv.MinY) / -adfThisGeoTransform[5] + 0.5);
GDALSetGenImgProjTransformerDstGeoTransform( hTransformArg, adfThisGeoTransform);
// create new raster
CPLString sOutputRasterPath = CPLResetExtension(sFileName, "tif");
GDALDataset *poDstDataset = poOutputDriver->Create(sOutputRasterPath, nPixels, nLines, poSrcDataset->GetRasterCount(), GDT_Byte, NULL );
if( NULL == poDstDataset )
{
Usage( "Create Output failed" );
return EXIT_FAILURE;
}
poDstDataset->SetProjection( pszSpaRefDef );
poDstDataset->SetGeoTransform( adfThisGeoTransform );
#ifdef APRROX_MAXERROR
hTransformArg = GDALCreateApproxTransformer( GDALGenImgProjTransform, hTransformArg, APRROX_MAXERROR);
GDALTransformerFunc pfnTransformer = GDALApproxTransform;
GDALApproxTransformerOwnsSubtransformer(hTransformArg, TRUE);
#else
GDALTransformerFunc pfnTransformer = GDALGenImgProjTransform;
#endif // APRROX_MAXERROR
// warp
GDALWarpOptions *psWO = GDALCreateWarpOptions();
psWO->eWorkingDataType = GDT_Byte;
psWO->eResampleAlg = GRA_NearestNeighbour;
psWO->hSrcDS = poSrcDataset;
psWO->hDstDS = poDstDataset;
psWO->pfnTransformer = pfnTransformer;
psWO->pTransformerArg = hTransformArg;
psWO->pfnProgress = GDALTermProgress;
psWO->nBandCount = poSrcDataset->GetRasterCount();
psWO->panSrcBands = (int *) CPLMalloc(psWO->nBandCount*sizeof(int));
psWO->panDstBands = (int *) CPLMalloc(psWO->nBandCount*sizeof(int));
for(int i = 0; i < psWO->nBandCount; ++i )
{
psWO->panSrcBands[i] = i+1;
psWO->panDstBands[i] = i+1;
}
GDALWarpOperation oWO;
if( oWO.Initialize( psWO ) == CE_None )
{
#ifdef MULTI
if( oWO.ChunkAndWarpMulti( 0, 0, poDstDataset->GetRasterXSize(), poDstDataset->GetRasterYSize() ) != CE_None)
#else //MULTI
if( oWO.ChunkAndWarpImage( 0, 0, poDstDataset->GetRasterXSize(), poDstDataset->GetRasterYSize() ) != CE_None)
#endif //MULTI
{
const char* err = CPLGetLastErrorMsg();
Usage( CPLSPrintf("Warp failed.%s", err) );
return EXIT_FAILURE;
}
}
// cleanup
GDALDestroyWarpOptions( psWO );
CSLDestroy( papszTO );
CPLFree( pszSpaRefDef );
GDALClose( (GDALDatasetH) poSrcDataset );
GDALClose( (GDALDatasetH) poDstDataset );
GDALDestroyDriverManager();
return EXIT_SUCCESS;
}
point get_point()
{
point pt3(22, 99);
return pt3;
}
