SuperqModule Class Reference

The SuperqModule class handle the superquadric computation and visualization, the point cloud and superquadric filtering and the interaction with the user. More...

#include <superqModule.h>

Inheritance diagram for SuperqModule:

Public Member Functions
double	getPeriod ()
	Get period function of RF module. More...
bool	updateModule ()
	updateModule function of RF module
bool	configure (yarp::os::ResourceFinder &rf)
	configure function of RF module
bool	interruptModule ()
	interrupt module function of RF module
bool	close ()
	close function of RF module
bool	configOnOff (yarp::os::ResourceFinder &rf)
	Configure all on/off options.
bool	configFilter (yarp::os::ResourceFinder &rf)
	Configure point cloud filter options.
bool	configFilterSuperq (yarp::os::ResourceFinder &rf)
	Configure superquadric filter options.
bool	configServices (yarp::os::ResourceFinder &rf)
	Open ports for communication.
bool	configSuperq (yarp::os::ResourceFinder &rf)
	Configure superquadric computation otpions.
bool	configViewer (yarp::os::ResourceFinder &rf)
	Configure visualization options.
void	saveSuperq ()
	Save computed superquadric.
bool	set_save_points (const std::string &entry)
	Set if to save or not the used point cloud. More...
std::string	get_save_points ()
	Get if the used point cloud is saved or not. More...
bool	readPointCloud ()
	In offline mode, read the point cloud from a txt file.
virtual yarp::os::Property	get_superq (const std::vector< yarp::sig::Vector > &point_cloud, const bool filtered_or_not, const bool reset_or_not)
	Get the parameters of the reconstructed superquadric. More...
virtual bool	read (yarp::os::ConnectionReader &connection)
virtual std::vector< std::string >	help (const std::string &functionName="--all")

Protected Member Functions
bool	attach (yarp::os::RpcServer &source)
bool	set_tag_file (const std::string &tag_file)
	Set a tag name for saving the superquadric. More...
std::string	get_tag_file ()
	Get the tag name used for saving the superquadric. More...
std::string	get_visualization ()
	Return if visualization is on or off. More...
bool	set_visualization (const std::string &e)
	Set if visualization is on or off. More...
yarp::os::Property	get_superq (const std::vector< yarp::sig::Vector > &blob)
	Return the computed superquadric, given the 2D blob of the object. More...
bool	send_point_clouds (const std::vector< yarp::sig::Vector > &p)
	Get the point cloud for computing the superquadric. More...
bool	reset_filter ()
	Reset median filter for improving superquadric estimation. More...
yarp::os::Property	get_superq_filtered ()
	Return the filtered superquadric. More...
yarp::os::Property	fillProperty (const yarp::sig::Vector &sol)
	Property fill the property with the superquadric solution. More...
bool	set_points_filtering (const std::string &entry)
	Set if to filter or not the point cloud. More...
std::string	get_points_filtering ()
	Get if the point cloud is filtered or not. More...
bool	set_superq_filtering (const std::string &entry)
	Set if to filter or not the superquadric. More...
std::string	get_superq_filtering ()
	Get if the superquadric is filtered or not. More...
yarp::os::Property	get_options (const std::string &field)
	Get options of a given field: visualization, optimization, filtering. More...
bool	set_options (const yarp::os::Property &newOptions, const std::string &field)
	Set options of specified field: visualization, optimization, filtering. More...
bool	set_object_class (const std::string &objclass)
	Set object class for improving superquadric estimation. More...

Protected Attributes
int	r
	Red value for visualization.
int	g
	Green value for visualization.
int	b
	Blue value for visualization.
int	count
	Count variable.
int	rate
	Computation thread rate.
int	rate_vis
	Visualization thread rate.
std::string	tag_file
	Tag name of files for saving 3D points.
std::string	homeContextPath
	Path where code context is located.
yarp::os::ConstString	pointCloudFileName
	Pointcloud name file in case the module runs offline.
std::string	outputFileName
	Output file name saving the estimated superquadric.
std::vector< cv::Point >	contour
	OpenCV variable for blob extraction.
std::deque< yarp::sig::Vector >	points
	3D points used for reconstructing the superquadric
std::deque< yarp::sig::Vector >	points_aux
	3D points auxiliary used for reconstructing the superquadric
std::deque< cv::Point >	blob_points
	2D points of the segmented object
double	radius
	Radius for spatial density filter.
int	nnThreshold
	Density threshold for spatial density filter.
int	numVertices
int	median_order
	Median filder order.
int	min_median_order
	Minimum median filder order allowed.
int	max_median_order
	Maximum median filder order allowed.
int	new_median_order
	New median filder order estimated.
bool	filter_points
	Boolean variable for enabling point cloud filtering.
bool	fixed_window
	Boolean variable for enabling the use of a fixed window during the median filter.
bool	filter_superq
	Boolean variable for enabling superquadric filtering.
std::string	what_to_plot
	String used for deciding what to plot: "points" or "superq".
double	threshold_median
	Threshold for velocity estimation for median order.
double	min_norm_vel
	Minimum norm of velocity for considering the object moving.
bool	mode_online
	Boolean variable for enabling online or offline mode.
bool	visualization_on
	Boolean variable for enabling visualization.
bool	go_on
	Boolean variable for going to the next step of the state machine.
bool	reset
	Boolean variable for resetting the median filter.
bool	save_points
	Boolean variable for enabling point cloud saving.
double	tol
	Tolerance of the optimization problem.
double	sum
double	max_cpu_time
	Max cpu time allowed for solving the optimization problem.
int	acceptable_iter
	Acceptable iter of Ipopt algorithm.
int	max_iter
	Maximum iteration allowed of Ipopt algorithm.
int	optimizer_points
	Number of 3D points used for optimization.
std::string	mu_strategy
	Mu strategy of the Ipopt algorithm.
std::string	nlp_scaling_method
	NLP scaling method of the Ipopt algorithm.
yarp::sig::Vector	x
	Estimated superquadric.
yarp::sig::Vector	x_filtered
	Filtered superquadric.
double	t_superq
	Time required for computing superquadric.
std::deque< double >	times_superq
	Times used for computing several superquadrics.
double	t_vis
	Time for visualization.
std::deque< double >	times_vis
	Collections of times required for visualization.
yarp::os::BufferedPort< yarp::os::Property >	portSuperq
	Port for streaming the computed superquadric.
yarp::os::RpcServer	portRpc
	Rpc port for interaction.
int	vis_points
	Number of points used for visualization.
int	vis_step
	Number of visualization step.
std::string	eye
	Eye camera selected.
yarp::sig::Matrix	R
yarp::sig::Matrix	H
yarp::sig::Matrix	K
yarp::sig::Vector	point
yarp::sig::Vector	point1
yarp::sig::Vector	point2D
std::deque< int >	Color
	Color used for visualization.
yarp::dev::PolyDriver	GazeCtrl
	Gaze Control driver for visualization.
yarp::dev::IGazeControl *	igaze
	Gaze Control interface.
yarp::os::ResourceFinder *	rf
double	t
double	t0
std::deque< std::string >	advanced_params
yarp::os::Mutex	mutex
yarp::os::Mutex	mutex_shared
std::string	object_class
SuperqComputation *	superqCom
	SuperqComputation class actually computes the superquadric.
SuperqVisualization *	superqVis
	SuperqVisualization class shows the estimated superquadric.
yarp::os::Property	filter_points_par
	Parameters of point cloud filter.
yarp::os::Property	filter_superq_par
	Parameters of superquadric filter.
yarp::os::Property	ipopt_par
	Parameters of the Ipopt optimization problem.

Detailed Description

The SuperqModule class handle the superquadric computation and visualization, the point cloud and superquadric filtering and the interaction with the user.

It is used to set all the parameters (offline and online) and to launch all the thread for superquadric computation and visualization.

Definition at line 40 of file superqModule.h.

Member Function Documentation

fillProperty()

Property SuperqModule::fillProperty ( const yarp::sig::Vector &  sol )

protected

Property fill the property with the superquadric solution.

Parameters

sol	is a Vector of the computed superquadric

Returns

a Property with the solution

Definition at line 187 of file superqModule.cpp.

{
    Property superq;

    Bottle bottle;
    Bottle &b1=bottle.addList();
    b1.addDouble(sol[0]); b1.addDouble(sol[1]); b1.addDouble(sol[2]);
    superq.put("dimensions", bottle.get(0));

    Bottle &b2=bottle.addList();
    b2.addDouble(sol[3]); b2.addDouble(sol[4]);
    superq.put("exponents", bottle.get(1));

    Bottle &b3=bottle.addList();
    b3.addDouble(sol[5]); b3.addDouble(sol[6]); b3.addDouble(sol[7]);
    superq.put("center", bottle.get(2));

    Bottle &b4=bottle.addList();
    Vector orient=dcm2axis(euler2dcm(sol.subVector(8,10)));
    b4.addDouble(orient[0]); b4.addDouble(orient[1]); b4.addDouble(orient[2]); b4.addDouble(orient[3]);
    superq.put("orientation", bottle.get(3));
    return superq;
}

get_options()

Property SuperqModule::get_options ( const std::string &  field )

protectedvirtual

Get options of a given field: visualization, optimization, filtering.

Parameters

field

is one of the field of options

Returns

property with the options of interested

Reimplemented from superquadricModel_IDL.

Definition at line 330 of file superqModule.cpp.

{
    Property advOptions;
    if (field=="points_filter")
        advOptions=superqCom->getPointsFilterPar();
    else if (field=="superq_filter")
        advOptions=superqCom->getSuperqFilterPar();
    else if (field=="optimization")
        advOptions=superqCom->getIpoptPar();
    else if (field=="visualization")
        advOptions=superqVis->getPar();
    else if (field=="statistics")
    {
        advOptions.put("average_computation_time", t_superq);
        advOptions.put("average_visualization_time", t_vis);
    }       

    return advOptions;
}

get_points_filtering()

string SuperqModule::get_points_filtering ( )

protectedvirtual

Get if the point cloud is filtered or not.

Returns

"on" or "off"

Reimplemented from superquadricModel_IDL.

Definition at line 242 of file superqModule.cpp.

{
    if (filter_points)
    {
        return "on";
    }
    else
    {
        return "off";
    }
}

get_save_points()

string SuperqModule::get_save_points ( )

virtual

Get if the used point cloud is saved or not.

Returns

"on" or "off"

Reimplemented from superquadricModel_IDL.

Definition at line 304 of file superqModule.cpp.

{
    if (save_points)
    {
        return "on";
    }
    else
    {
        return "off";
    }
}

get_superq() [1/2]

virtual yarp::os::Property superquadricModel_IDL::get_superq ( const std::vector< yarp::sig::Vector > &  point_cloud, const bool  filtered_or_not, const bool  reset_or_not  )

virtualinherited

Get the parameters of the reconstructed superquadric.

Parameters

point_cloud	is the 3D point cloud of the object we want to model with the superquadric, for instance: ((100.0 102.0) (100.0 103.0) ... ).
filtered_or_not	is a bool variable specifing if we want the superquadric to be filtered (true/1) or not (false/0).
reset_or_not	is a bool variable specifing if we want to reset the superquadric filtered (if enabled) or not.

Returns

the 12 parameters (x0, .. x11) of the current superquadric. In particular, the parameters are grouped in a Property as follows: "dimensions" (x0, x1, x2) are the three semi-axes lenghts; "exponents" (x3 and x4) are the exponents, responsible for the superquadric shape; "center"(x5, x6, x7) contains the coordinate of the superquadric center; and "orientation" (x8, x9, 10, x11) is the axis-angle representation obtained from the Euler angles.

get_superq() [2/2]

Property SuperqModule::get_superq ( const std::vector< yarp::sig::Vector > &  blob )

protected

Return the computed superquadric, given the 2D blob of the object.

Parameters

blob	is the 2D blob of the object

Returns

a property with the estimated superquadric

Definition at line 99 of file superqModule.cpp.

{
    Property superq;

    LockGuard lg(mutex);

    superqCom->setPar("object_class", object_class);

    superqCom->setPar("one_shot", "on");

    deque<Vector> p_aux;
    
    for (size_t i=0; i<p.size(); i++)
        p_aux.push_back(p[i]);

    superqCom->sendPoints(p_aux);

    superqCom->run();

    Vector sol(11,0.0);
    sol=superqCom->getSolution(0);

    superqCom->setPar("one_shot", "off");

    p_aux.clear();
    superqCom->sendPoints(p_aux);

    superq=fillProperty(sol);

    return superq;
}

get_superq_filtered()

Property SuperqModule::get_superq_filtered ( )

protected

Return the filtered superquadric.

Returns

a property with the filtered superquadric

Definition at line 170 of file superqModule.cpp.

{
    Property superq;
    Vector sol(11,0.0);
    sol=superqCom->getSolution(1);

    superqCom->setPar("one_shot", "off");
    deque<Vector> p_aux;
    p_aux.clear();
    superqCom->sendPoints(p_aux);

    superq=fillProperty(sol);

    return superq;
}

get_superq_filtering()

string SuperqModule::get_superq_filtering ( )

protectedvirtual

Get if the superquadric is filtered or not.

Returns

"on" or "off"

Reimplemented from superquadricModel_IDL.

Definition at line 291 of file superqModule.cpp.

{
    if (filter_superq)
    {
        return "on";
    }
    else
    {
        return "off";
    }
}

get_tag_file()

string SuperqModule::get_tag_file ( )

protectedvirtual

Get the tag name used for saving the superquadric.

Returns

the currect name of the file used for saving

Reimplemented from superquadricModel_IDL.

Definition at line 57 of file superqModule.cpp.

{
    return tag_file;
}

get_visualization()

string SuperqModule::get_visualization ( )

protectedvirtual

Return if visualization is on or off.

Returns

"on" or "off"

Reimplemented from superquadricModel_IDL.

Definition at line 63 of file superqModule.cpp.

{
    if (visualization_on)
        return "on";
    else
        return "off";
}

getPeriod()

double SuperqModule::getPeriod

(

)

Get period function of RF module.

Returns

the period

Definition at line 376 of file superqModule.cpp.

{
    return 0.0;
}

reset_filter()

bool SuperqModule::reset_filter ( )

protected

Reset median filter for improving superquadric estimation.

Returns

true

Definition at line 162 of file superqModule.cpp.

{
    superqCom->resetMedianFilter();

    return true;
}

send_point_clouds()

bool SuperqModule::send_point_clouds ( const std::vector< yarp::sig::Vector > &  p )

protected

Get the point cloud for computing the superquadric.

Parameters

p	is the point cloud to be acquired

Returns

true

Definition at line 132 of file superqModule.cpp.

{
    double t, t_fin;  
    
    t=Time::now();

    superqCom->setPar("object_class", object_class);

    yDebug()<<"Time operations  after set par 1"<<Time::now() - t;

    superqCom->setPar("one_shot", "on");

    yDebug()<<"Time operations after set par 2"<<Time::now() - t;

    deque<Vector> p_aux;

    for (size_t i=0; i<p.size(); i++)
        p_aux.push_back(p[i]);

    superqCom->sendPoints(p_aux);
    yDebug()<<"Time operations send points "<<Time::now() - t;

    t_fin= Time::now() - t;

    yDebug()<<"Time operations  final"<<t_fin;

    return true;
}

set_object_class()

bool SuperqModule::set_object_class ( const std::string &  objclass )

protected

Set object class for improving superquadric estimation.

Parameters

objclass

is the object class (according to the shape)

Returns

true/false on success/failure

Definition at line 368 of file superqModule.cpp.

{
    object_class=objclass;

    return true;
}

set_options()

bool SuperqModule::set_options ( const yarp::os::Property &  newOptions, const std::string &  field  )

protectedvirtual

Set options of specified field: visualization, optimization, filtering.

Parameters

newOptions	is a property with the options to be set
field	is the field of the options to be set

Returns

true/false on success/failure

Reimplemented from superquadricModel_IDL.

Definition at line 351 of file superqModule.cpp.

{
    if (field=="points_filter")
        superqCom->setPointsFilterPar(newOptions, false);
    else if (field=="superq_filter")
        superqCom->setSuperqFilterPar(newOptions, false);
    else if (field=="optimization")
        superqCom->setIpoptPar(newOptions, false);
    else if (field=="visualization")
        superqVis->setPar(newOptions, false);
    else
        return false;

    return true;
}

set_points_filtering()

bool SuperqModule::set_points_filtering ( const std::string &  entry )

protectedvirtual

Set if to filter or not the point cloud.

Parameters

entre

can be "on" or "off"

Returns

true/false on success/failure

Reimplemented from superquadricModel_IDL.

Definition at line 212 of file superqModule.cpp.

{
    if ((entry=="on") || (entry=="off"))
    {
        LockGuard lg(mutex);
        filter_points=(entry=="on");
        if (filter_points)
        {
            Property options;
            options.put("filter_radius", radius);
            options.put("filter_nnThreshold", nnThreshold);
            superqCom->setPointsFilterPar(options, false);
            superqCom->setPar("filter_points", "on");
        }
        else
            superqCom->setPar("filter_points", "off");

        yInfo()<<"[SuperqModule]: filter_points "<<filter_points;
        yInfo()<<"[SuperqModule]: radius        "<<radius;
        yInfo()<<"[SuperqModule]: nn-thrshold   "<<nnThreshold;

        return true;    
    }
    else
    {        
        return false;
    }
}

set_save_points()

bool SuperqModule::set_save_points ( const std::string &  entry )

virtual

Set if to save or not the used point cloud.

Parameters

entry

can be "on" or "off"

Reimplemented from superquadricModel_IDL.

Definition at line 317 of file superqModule.cpp.

{
    if ((entry=="on") || (entry=="off"))
    {
        save_points=(entry=="on");
        if (save_points)
            superqCom->setPar("save_points", "on");
        else
            superqCom->setPar("save_points", "off");
    }    
}

set_superq_filtering()

bool SuperqModule::set_superq_filtering ( const std::string &  entry )

protectedvirtual

Set if to filter or not the superquadric.

Parameters

entry

can be "on" or "off"

Returns

true/false on success/failure

Reimplemented from superquadricModel_IDL.

Definition at line 255 of file superqModule.cpp.

{
    if ((entry=="on") || (entry=="off"))
    {
        LockGuard lg(mutex);
        filter_superq= (entry=="on");
        if (filter_superq)
        {
            Property options;
            options.put("median_order", median_order);
            if (fixed_window)
                options.put("fixed_window", "on");
            else
                options.put("fixed_window", "off");

            superqCom->setSuperqFilterPar(options, false);
            superqCom->setPar("filter_superq", "on");
        }
        else
            superqCom->setPar("filter_superq", "off");

        yInfo()<<"[SuperqModule]: filter_superq         "<<filter_superq;
        yInfo()<<"[SuperqModule]: fixed_window          "<<fixed_window;
        yInfo()<<"[SuperqModule]: median_order          "<<median_order;
        yInfo()<<"[SuperqModule]: min_median_order      "<<min_median_order;
        yInfo()<<"[SuperqModule]: max_median_order      "<<max_median_order;

        return true;        
    }
    else
    {
        return false;
    }
}

set_tag_file()

bool SuperqModule::set_tag_file ( const std::string &  tag_file )

protectedvirtual

Set a tag name for saving the superquadric.

Parameters

tag_file

is the name of the file where to save the superquadric

Returns

true

Reimplemented from superquadricModel_IDL.

Definition at line 43 of file superqModule.cpp.

{
    LockGuard lg(mutex);

    tag_file=tag;
    outputFileName=homeContextPath+"/"+tag_file+".txt";
    yDebug()<<" [SuperqModule]: File output "<<outputFileName;

    superqCom->setPar("tag_file", tag_file);

    return true;
}

set_visualization()

bool SuperqModule::set_visualization ( const std::string &  e )

protectedvirtual

Set if visualization is on or off.

Parameters

e	can be "on" or "off"

Returns

true/false on success/failure

Reimplemented from superquadricModel_IDL.

Definition at line 72 of file superqModule.cpp.

{
    if ((e=="on") || (e=="off"))
    {
        LockGuard lg(mutex);

        if ((visualization_on==false) && (e=="on"))
        {
            superqVis->resume();

            visualization_on=true;

        }
        else if ((visualization_on==true) && (e=="off"))
        {
            superqVis->suspend();
            visualization_on=false;
        }
        return true;
    }
    else
    {
        return false;
    }
}

---

The documentation for this class was generated from the following files:

• C:/Users/upattacini/Desktop/superquadric-model/include/superqModule.h
• C:/Users/upattacini/Desktop/superquadric-model/src/superqModule.cpp