Cppcheck report - CGM: src/geom/facet/FacetParamTool.cpp

//===================================================================================
//
// File: FacetParamTool.cpp
//
// Descripiton: interface for 3D-2D parameterization algorithms
//
//===================================================================================


#include "FacetParamTool.hpp"
#include "CastTo.hpp"
#include "Surface.hpp"
#include "FacetSurface.hpp"
#include "FacetEvalTool.hpp"
#include "FacetorTool.hpp"
#include "CubitPoint.hpp"
#include "CubitPointData.hpp"
#include "CubitFacet.hpp"
#include "CubitFacetData.hpp"
#include "CubitBox.hpp"
#include "TDFacetBoundaryPoint.hpp"

#ifdef ROADKILL
#include "ParamManager.hpp"
#endif

#define DETERM(p1,q1,p2,q2,p3,q3)\
     ((q3)*((p2)-(p1)) + (q2)*((p1)-(p3)) + (q1)*((p3)-(p2)))
#define INSIDE_TOL 1.0e-6

//===================================================================================
// Function: FacetParamTool (Public)
// Description: Constructor
// Author: chynes
// Date: 1/02
//===================================================================================
FacetParamTool::FacetParamTool(int numn, int nume, double* nodes, int* tri) 
{}


//-------------------------------------------------------------------------
// Function:    FacetParamTool
// Description: constructor
// Author:      chynes
// Date:        7/10/2002
//-------------------------------------------------------------------------
FacetParamTool::FacetParamTool(Surface *surf) 
{
	refSurf = surf;
}

//===================================================================================
// Function: ~FacetParamTool
// Description: Deconstructor
// Author: chynes
// Date: 1/02
//===================================================================================
FacetParamTool::~FacetParamTool() {}

//===================================================================================
// Function: set_up_space (Public)
// Description: sets up space of flattening, flattens, and then updates surface
// Author: chynes
// Date: 7/10/02
//===================================================================================
CubitStatus FacetParamTool::set_up_space() 
{ 
#ifdef ROADKILL
	FacetEvalTool *fetool = CAST_TO(refSurf, FacetSurface)->get_eval_tool();

	if ((fetool->loops())->size() != 1)
	{
		PRINT_WARNING("Cannot parameterize surface.  Multiple loops detected\n");
		return CUBIT_FAILURE;
	}

	DLIList<CubitPoint *> my_point_list;
	fetool->get_points(my_point_list);
	DLIList<CubitFacet *> my_facet_list;
	fetool->get_facets(my_facet_list);

  // make arrays out of the points and facets
	double *points = new double [3 * my_point_list.size()];
	int *facets = new int [3 * my_facet_list.size()];
	if (!points || !facets)
	{
		PRINT_ERROR("Could not define parameterization for surface (out of memory)\n");
		return CUBIT_FAILURE;
	}
	int ii;
	CubitPoint *pt;
	my_point_list.reset();
	for (ii=0; ii<my_point_list.size(); ii++)
	{
		pt = my_point_list.get_and_step();
		points[ii*3] = pt->x();
		points[ii*3+1] = pt->y();
		points[ii*3+2] = pt->z();
		pt->marked(ii);
	}
	CubitFacet *facet;
<--- The scope of the variable 'facet' can be reduced. [+]
The scope of the variable 'facet' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
	CubitPoint *pts[3];
	for (ii=0; ii<my_facet_list.size(); ii++)
	{
		facet = my_facet_list.get_and_step();    
		facet->points( pts[0], pts[1], pts[2] );
		facets[ii*3]   = pts[0]->marked();
		facets[ii*3+1] = pts[1]->marked();
		facets[ii*3+2] = pts[2]->marked();
	}

	//debug, export facets
//	export_facets(my_point_list.size(), my_facet_list.size(), points, facets);
//	PRINT_ERROR("Debugging Failure.  Please remove export_facets from FacetParamTool\n");
//	return CUBIT_FAILURE;

	// do the parameterization
	ParamManager parammanager( my_point_list.size(), my_facet_list.size(),
							points, facets );
	if(!parammanager.flatten())
	{
		PRINT_ERROR("Surface Parameterizer Failed\n");
		return CUBIT_FAILURE;
	}
	else
	{
		double ratio;
		double *sizes;
		parammanager.build_sizing();
		double *uv = parammanager.get_uvs_sizing( ratio, sizes ); 
		
		// update the points with uvs values

		TDFacetBoundaryPoint *td_fbp;
		CubitBoolean on_internal_boundary;
		my_point_list.reset();
		for (ii=0; ii<my_point_list.size(); ii++)
		{
			pt = my_point_list.get_and_step();
			DLIList <CubitFacet *> facet_list;
			pt->facets_on_surf( fetool->tool_id(), facet_list, on_internal_boundary );
			if (on_internal_boundary)
			{
				td_fbp = TDFacetBoundaryPoint::get_facet_boundary_point( pt );
				if (!td_fbp)
				{
					TDFacetBoundaryPoint::add_facet_boundary_point( pt );
					td_fbp = TDFacetBoundaryPoint::get_facet_boundary_point( pt );
					td_fbp->add_surf_facets( facet_list );
					td_fbp->set_uvs( facet_list.get(), uv[ii*2], uv[ii*2+1], sizes[ii]);
				}
				else
				{
					if (td_fbp->set_uvs( facet_list.get(),
						uv[ii*2], uv[ii*2+1], sizes[ii] ) != CUBIT_SUCCESS)
					{
						td_fbp->add_surf_facets( facet_list );
						td_fbp->set_uvs( facet_list.get(), uv[ii*2], uv[ii*2+1], sizes[ii]);
					}
				}
			}
			else
			{
				pt->set_uvs( uv[ii*2], uv[ii*2+1], sizes[ii]);
			}
		}
	
		PRINT_INFO("Surface Parameterization succeeded\n");
		delete [] sizes;
		delete [] uv;
    
	}
	
	// clean up

	delete [] points;
	delete [] facets;
	return CUBIT_SUCCESS;

#else
	return CUBIT_FAILURE;
#endif

}

//===================================================================================
// Function: transform_to_uv (Public)
// Description: same as title, set_up_space must have been already called
// the local sizing will be returned in the z coord 
// of the uv location vector
// Author: chynes
// Date: 7/10/02
//===================================================================================
CubitStatus FacetParamTool::transform_to_uv(const CubitVector &xyz_location, CubitVector &uv_location) 
{
	DLIList<CubitFacet *> facet_list; 
	FacetEvalTool *fetool;
	CubitFacet *tri_ptr;
	CubitBoolean outside = CUBIT_FALSE;
	CubitVector closest_point;
	CubitVector area_coord;
	double u, v, s;
<--- The scope of the variable 'u' can be reduced. [+]
The scope of the variable 'u' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
<--- The scope of the variable 'v' can be reduced. [+]
The scope of the variable 'v' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
<--- The scope of the variable 's' can be reduced. [+]
The scope of the variable 's' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
	double compare_tol;

	// find best compare_tol
	fetool = CAST_TO(refSurf, FacetSurface)->get_eval_tool();
	compare_tol = 1e-3*(fetool->bounding_box().diagonal().length());

	// locate point
	CubitStatus rv = CUBIT_SUCCESS;
	fetool->get_facets(facet_list);
	rv = FacetEvalTool::project_to_facets(facet_list, 
										  tri_ptr, 
										  0, 
										  compare_tol, 
										  xyz_location, 
										  CUBIT_FALSE, 
										  &outside, 
										  &closest_point, 
										  NULL);
	// determine barycentric coordinates for in facet
	if(rv == CUBIT_SUCCESS) 
	{
		FacetEvalTool::facet_area_coordinate(tri_ptr, closest_point, area_coord);

		// extract data
		double u0, u1, u2, v0, v1, v2, s0, s1, s2;
		CubitPoint *p0, *p1, *p2;
		tri_ptr->points(p0, p1, p2);
		p0->get_uvs(tri_ptr, u0, v0, s0);
		p1->get_uvs(tri_ptr, u1, v1, s1);
		p2->get_uvs(tri_ptr, u2, v2, s2);

		// determine u coordinate
		u = (area_coord.x()*u0) + (area_coord.y()*u1) + (area_coord.z()*u2);

		// determine v coordinate
		v = (area_coord.x()*v0) + (area_coord.y()*v1) + (area_coord.z()*v2);

		// determine sizing
		s = (area_coord.x()*s0) + (area_coord.y()*s1) + (area_coord.z()*s2);

		uv_location.set(u,v,s);
	}

		return rv;	
}

//===================================================================================
// Function: transform_to_xyz (Public)
// Description: same as title
// Author: chynes
// Date: 7/10/02
//===================================================================================
CubitStatus FacetParamTool::transform_to_xyz(CubitVector &xyz_location, const CubitVector &uv_location) 
{
	CubitStatus rv = CUBIT_SUCCESS;
	CubitFacet *tri_ptr;
	FacetSurface *facet_surf = CAST_TO(refSurf, FacetSurface);
	CubitVector area_coord;
	double x, y, z;
<--- The scope of the variable 'x' can be reduced. [+]
The scope of the variable 'x' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
<--- The scope of the variable 'y' can be reduced. [+]
The scope of the variable 'y' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
<--- The scope of the variable 'z' can be reduced. [+]
The scope of the variable 'z' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.

	//locate point
	rv = locate_point_in_uv(facet_surf, uv_location, tri_ptr);

	if(rv == CUBIT_SUCCESS)
	{
		// create uv facet
		CubitPoint* uvpoint_array[3];
		DLIList<CubitPoint *> point_list;
		CubitPoint *pt_ptr;
		double u,v;
		int ii;
		tri_ptr->points(point_list);
		for(ii = 0; ii<3; ii++)
		{
			pt_ptr = point_list.get_and_step();
			pt_ptr->get_uv(tri_ptr, u, v);
			uvpoint_array[ii] = (CubitPoint *) new CubitPointData(u, v, 0.0);
		}
		CubitFacet *uvfacet_ptr = (CubitFacet *) new CubitFacetData( uvpoint_array[0], 
																	 uvpoint_array[1], 
																	 uvpoint_array[2] );

		// determine barycentric coordinates of uv point in uv facet
		FacetEvalTool::facet_area_coordinate(uvfacet_ptr, uv_location, area_coord);

		//delete created objects
		delete uvfacet_ptr;
		for(ii = 0; ii<3; ii++)
		{
			pt_ptr = uvpoint_array[ii];
			delete pt_ptr;
		}

		CubitPoint *p0, *p1, *p2;
		CubitVector coord0, coord1, coord2;
		tri_ptr->points(p0,p1,p2);
		coord0 = p0->coordinates();
		coord1 = p1->coordinates();
		coord2 = p2->coordinates();

		//determine x coordinate
		x =   (area_coord.x()*coord0.x())
			+ (area_coord.y()*coord1.x())
			+ (area_coord.z()*coord2.x());
		//determine y coordinate
		y =   (area_coord.x()*coord0.y())
			+ (area_coord.y()*coord1.y())
			+ (area_coord.z()*coord2.y());
		//determine z coordinate
		z =   (area_coord.x()*coord0.z())
			+ (area_coord.y()*coord1.z())
			+ (area_coord.z()*coord2.z());

		xyz_location.set(x,y,z);

	}

	return rv;
}


//===================================================================================
// Function: locate_point_in_uv (Public)
// Description: same as title (the_point must have coords (u,v,0.0))
// Author: chynes
// Date: 7/10/02
//===================================================================================
CubitStatus FacetParamTool::
locate_point_in_uv(FacetSurface *surf, const CubitVector &the_point, CubitFacet *&tri_ptr) 
{
	CubitStatus rv = CUBIT_SUCCESS;

	DLIList<CubitFacet *> facet_list;
	int tool_id = surf->get_eval_tool()->tool_id();
	surf->get_eval_tool()->get_facets(facet_list);
	tri_ptr = facet_list.get();

	// loop until we find something

	CubitPoint *p0, *p1, *p2;
	double aa, bb, cc;
<--- The scope of the variable 'aa' can be reduced. [+]
The scope of the variable 'aa' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
<--- The scope of the variable 'bb' can be reduced. [+]
The scope of the variable 'bb' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
<--- The scope of the variable 'cc' can be reduced. [+]
The scope of the variable 'cc' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
	double u0, u1, u2, v0, v1, v2;
	CubitBoolean found = CUBIT_FALSE;
	while(!found && rv == CUBIT_SUCCESS)
	{
		tri_ptr->points(p0, p1, p2);
		p0->get_uv(tri_ptr, u0, v0);
		p1->get_uv(tri_ptr, u1, v1);
		p2->get_uv(tri_ptr, u2, v2);
		aa = DETERM(the_point.x(), the_point.y(), u1, v1, u2, v2);
		bb = DETERM(u0, v0, the_point.x(), the_point.y(), u2, v2);
		cc = DETERM(u0, v0, u1, v1, the_point.x(), the_point.y());
		if (aa > -INSIDE_TOL &&
			bb > -INSIDE_TOL &&
			cc > -INSIDE_TOL)
		{
			found = CUBIT_TRUE;  // this is the one
		}
		else
		{
			// set up to check the next logical neighbor
			if (aa <= bb && aa <= cc) {
				int edge_index = 1;
				tri_ptr = tri_ptr->adjacent( edge_index, &tool_id );
			}
			else if (bb <= aa && bb <= cc) {
				int edge_index = 2;
				tri_ptr = tri_ptr->adjacent( edge_index, &tool_id );
			}
			else {
				int edge_index = 0;
				tri_ptr = tri_ptr->adjacent( edge_index, &tool_id);
			}
			// check to see if we've left the triangulation
      
			if (tri_ptr == NULL)
			{
				rv = exhaustive_locate_point_in_uv(surf, the_point, tri_ptr );
				found = CUBIT_TRUE;
			}
		}
	}

	return rv;
}
//===================================================================================
// Function: exhaustive_locate_point_in_uv (Public)
// Description: same as title
// Author: chynes
// Date: 7/10/02
//===================================================================================
CubitStatus FacetParamTool::
exhaustive_locate_point_in_uv(FacetSurface *surf, const CubitVector &the_point, CubitFacet *&tri_ptr) 
{
	CubitStatus rv = CUBIT_SUCCESS;

	DLIList<CubitFacet *> facet_list;
	surf->get_eval_tool()->get_facets(facet_list);

	// loop until we find something

	CubitPoint *p0, *p1, *p2;
	int ii;
	double aa, bb, cc;
<--- The scope of the variable 'aa' can be reduced. [+]
The scope of the variable 'aa' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
<--- The scope of the variable 'bb' can be reduced. [+]
The scope of the variable 'bb' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
<--- The scope of the variable 'cc' can be reduced. [+]
The scope of the variable 'cc' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
	double u0, u1, u2, v0, v1, v2;
	CubitBoolean found = CUBIT_FALSE;
	for(ii = 0; ii < facet_list.size() && !found; ii++)
	{
		tri_ptr = facet_list.get_and_step();
		tri_ptr->points(p0, p1, p2);
		p0->get_uv(tri_ptr, u0, v0);
		p1->get_uv(tri_ptr, u1, v1);
		p2->get_uv(tri_ptr, u2, v2);
		aa = DETERM(the_point.x(), the_point.y(), u1, v1, u2, v2);
		bb = DETERM(u0, v0, the_point.x(), the_point.y(), u2, v2);
		cc = DETERM(u0, v0, u1, v1, the_point.x(), the_point.y());
		if (aa > -INSIDE_TOL &&
			bb > -INSIDE_TOL &&
			cc > -INSIDE_TOL)
		{
			found = CUBIT_TRUE;  // this is the one
		}
	}
	if (!found)
	{
		rv = CUBIT_FAILURE;
		tri_ptr = NULL;
	}
	return rv;
}

//===================================================================================
// Function: flatten
// Description: accessor function to the parameterization algorithms
// Author: chynes
// Date: 1/02
//====================================================================================


//EOF