Exemplo n.º 1
0
/* Calculus 9-3 Ellipse
 * consider  (x^2/a^2)+(y^2)/(b^2)=1
 * where (-a,0),(a,0) is the major axis
 * and
 * where (-b,0),(b,0) is the minor axis
 * ->  a > 0
 * ->  b > 0
 */
int EllipseAverage(
     MAP_REAL8 *average,	/* write-only output average map  */ 
     const MAP_REAL8 *val, 	/* input value map */
     const MAP_REAL8 *xmajor, 	/* input window size map */
     const MAP_REAL8 *yminor, 	/* input window size map */
     const MAP_REAL8 *angle) 	/* input window size map */
{
	int 	r, c, nrRows, nrCols;

	val->SetGetTest(GET_MV_TEST, val);
	xmajor->SetGetTest(GET_MV_TEST, xmajor);
	yminor->SetGetTest(GET_MV_TEST, yminor);
	angle->SetGetTest(GET_MV_TEST,  angle);

	nrRows = val->NrRows(val);
	nrCols = val->NrCols(val);

	for (r = 0; r < nrRows; r++)
	 for (c = 0; c < nrCols; c++)
	{
		REAL8 value, xmajorV,yminorV,angleV;
		if(
		   xmajor->Get(&xmajorV, r, c, xmajor)&&
		   yminor->Get(&yminorV, r, c, yminor)&&
		    angle->Get(&angleV,  r, c, angle) )
		{
			REAL8 count = 0, winTotal = 0;
			int   rWin, cWin, pw; 
			REAL8 bw; /* border weigth */

			BuildCircle(fabs(xmajorV));
			return 0;
			average->PutMV(r, c, average);

			/* Calculate in window */
			for(rWin = -pw; rWin <= pw; rWin++)
			 for(cWin= -pw; cWin <= pw; cWin++)
			 {
				if(val->Get(&value, rWin+r, cWin+c, val))
				{
					REAL8 w = Weight(pw,rWin,cWin,bw);
					winTotal += value*w;
					count    += w;
				}
			 }
			if(count > 0)
			 average->Put(winTotal/count, r, c, average);
			else
			 average->PutMV(r, c, average);
		}
		else
			/* MV or winSize <= 0 */
			average->PutMV(r, c, average);
	}
	return 0;
}
Exemplo n.º 2
0
int main()
{
    Frustum frustum;

    osgViewer::CompositeViewer viewer;
    viewer.setThreadingModel(osgViewer::ViewerBase::SingleThreaded);

    // Circle
    Circle c;
    c.normal = osg::Vec3d(1,1,1);
    c.normal.normalize();

    c.center = osg::Vec3d(1,3,4);
    c.radius = 25;
    auto gp_circle = BuildCircle(c,osg::Vec4(0.5,0.5,0.5,1.0));

    // View0 root
    osg::ref_ptr<osg::Group> gp_root0 = new osg::Group;
    gp_root0->addChild(gp_circle);

    // View1 root
    osg::ref_ptr<osg::Group> gp_root1 = new osg::Group;
    gp_root1->addChild(gp_circle);

    // disable lighting and enable blending
    gp_root0->getOrCreateStateSet()->setMode( GL_LIGHTING,osg::StateAttribute::OFF);
    gp_root0->getOrCreateStateSet()->setMode( GL_BLEND,osg::StateAttribute::ON);
    gp_root0->getOrCreateStateSet()->setMode( GL_DEPTH_TEST,osg::StateAttribute::OFF);

    gp_root1->getOrCreateStateSet()->setMode( GL_LIGHTING,osg::StateAttribute::OFF);
    gp_root1->getOrCreateStateSet()->setMode( GL_BLEND,osg::StateAttribute::ON);
    gp_root1->getOrCreateStateSet()->setMode( GL_DEPTH_TEST,osg::StateAttribute::OFF);

    // Create View 0
    {
        osgViewer::View* view = new osgViewer::View;
        viewer.addView( view );

        view->setUpViewInWindow( 10, 10, 640, 480 );
        view->setSceneData( gp_root0.get() );
        view->getCamera()->setClearColor(osg::Vec4(0.1,0.1,0.1,1.0));

        osg::ref_ptr<osgGA::TrackballManipulator> view_manip =
                new osgGA::TrackballManipulator;
        view_manip->setMinimumDistance(100);

        view->setCameraManipulator(view_manip);

    }

    // Create view 1 (this view shows View0's frustum)
    {
        osgViewer::View* view = new osgViewer::View;
        viewer.addView( view );

        view->setUpViewInWindow( 10, 510, 640, 480 );
        view->setSceneData( gp_root1.get() );
        view->getCamera()->setClearColor(osg::Vec4(0.1,0.1,0.1,1.0));

        osg::ref_ptr<osgGA::TrackballManipulator> view_manip =
                new osgGA::TrackballManipulator;
        view_manip->setMinimumDistance(100);

        view->setCameraManipulator(view_manip);
    }

    while(!viewer.done())
    {
        osg::Camera * camera = viewer.getView(0)->getCamera();
        osg::Vec3d eye,vpt,up;
        double fovy,ar,near,far;
        camera->getViewMatrixAsLookAt(eye,vpt,up);
        camera->getProjectionMatrixAsPerspective(fovy,ar,near,far);
        osg::Vec3d viewdirn = vpt-eye;
        viewdirn.normalize();

        // new frustum
        auto new_frustum = BuildFrustumNode(camera,frustum);

        // new viewdirn
        auto new_viewdirn = BuildLine(eye,eye+(viewdirn*far),K_COLOR_GRAY);
        new_viewdirn->setName("viewdirn");

        // new closest point circle/point
        osg::Vec3d const cp_circle_pt = ClosestPointCirclePoint(c,eye);
        auto new_cp_circle_pt = BuildFacingCircle(cp_circle_pt,
                                                  eye.length()/150.0,
                                                  8,K_COLOR_RED);
        new_cp_circle_pt->setName("cp_circle_pt");

        // Update gp_root0
        {
            for(size_t i=0; i < gp_root0->getNumChildren(); i++) {
                std::string const name = gp_root0->getChild(i)->getName();
                // Remove prev camera node
                if(name == "cp_circle_pt") {
                    gp_root0->removeChild(i);
                    i--;
                }
            }
            // Add new nodes
            gp_root0->addChild(new_cp_circle_pt);
        }

        // Update gp_root1
        {
            for(size_t i=0; i < gp_root1->getNumChildren(); i++) {
                std::string const name = gp_root1->getChild(i)->getName();
                // Remove prev camera node
                if(name == "frustum") {
                    gp_root1->removeChild(i);
                    i--;
                }
                else if(name == "viewdirn") {
                    gp_root1->removeChild(i);
                    i--;
                }
                else if(name == "cp_circle_pt") {
                    gp_root1->removeChild(i);
                    i--;
                }
            }
            // Add new nodes
            gp_root1->addChild(new_frustum);
            gp_root1->addChild(new_viewdirn);
            gp_root1->addChild(new_cp_circle_pt);
        }

        viewer.frame();

    }
    return 0;
}