C++ CubitVector::set方法代码示例

// Constructor
SurfaceOverlapFacet::SurfaceOverlapFacet( GPoint p[3] )
{
  t.b.x = p[0].x;
  t.b.y = p[0].y;
  t.b.z = p[0].z;

  t.e0.x = p[1].x - p[0].x;
  t.e0.y = p[1].y - p[0].y;
  t.e0.z = p[1].z - p[0].z;

  t.e1.x = p[2].x - p[0].x;
  t.e1.y = p[2].y - p[0].y;
  t.e1.z = p[2].z - p[0].z;

  CubitVector min;
   
  min.set( CUBIT_MIN_3( p[0].x, p[1].x, p[2].x ),
    CUBIT_MIN_3( p[0].y, p[1].y, p[2].y ),
    CUBIT_MIN_3( p[0].z, p[1].z, p[2].z ) );
  
  CubitVector max;
  
  max.set( CUBIT_MAX_3( p[0].x, p[1].x, p[2].x ),
    CUBIT_MAX_3( p[0].y, p[1].y, p[2].y ),
    CUBIT_MAX_3( p[0].z, p[1].z, p[2].z ) );

  boundingBox.reset( min, max );
}

//===================================================================================
// Function: transform_to_uv (Public)
// Description: same as title, the local sizing will be returned in the z coord 
// Author: chynes
// Date: 7/10/02
//===================================================================================
CubitStatus PeriodicParamTool::transform_to_uv(const CubitVector &xyz_location, CubitVector &uv_location) 
{
	 
	double u,v;

	CubitStatus rv = refSurf->u_v_from_position(xyz_location, u, v);

	// offset values to avoid parameter discontinuity

	if (uPeriod && u < uOffset)
	{
		u += uPeriod;
	}
  
  // mirror surface if required to get correct loop orientation
  if (mirrorSurface)
  {
    u = -u;
  }

	if (vPeriod && v < vOffset)
	{
		v += vPeriod;
	}

	uv_location.set(u,v,1.0);


	return rv;
}

//-------------------------------------------------------------------------
// Purpose       : 
//
// Special Notes : 
//
// Creator       : Jason Kraftcheck
//
// Creation Date : 05/10/04
//-------------------------------------------------------------------------
CubitStatus PartitionBody::mass_properties( CubitVector& result, double& volume )
{
  DLIList<Lump*> lump_list;
  lumps( lump_list );
  
  DLIList<PartitionLump*> part_list;
  CAST_LIST( lump_list, part_list, PartitionLump );
  if (part_list.size() < lump_list.size())
    return real_body()->mass_properties( result, volume );
  
  CubitVector centroid(0.0, 0.0, 0.0), tmp_centroid;
  volume = 0.0;
  double tmp_volume;
  for (int i = part_list.size(); i--; )
  {
    if (CUBIT_FAILURE == 
        part_list.get_and_step()->mass_properties( tmp_centroid, tmp_volume ))
      return CUBIT_FAILURE;
    
    centroid += tmp_volume * tmp_centroid;
    volume += tmp_volume;
  }
  
  if (volume > CUBIT_RESABS)
  {
    result = centroid / volume;
  }
  else
  {
    result.set( 0.0, 0.0, 0.0 );
    volume = 0.0;
  }
  return CUBIT_SUCCESS;
}

// Constructor
CurveOverlapFacet::CurveOverlapFacet( GPoint p[2] )
{
  p0.set( p[0].x, p[0].y, p[0].z);
  p1.set( p[1].x, p[1].y, p[1].z);

  CubitVector min;
  min.set( CUBIT_MIN( p[0].x, p[1].x ),
           CUBIT_MIN( p[0].y, p[1].y ),
           CUBIT_MIN( p[0].z, p[1].z ) );
  
  CubitVector max;
  max.set( CUBIT_MAX( p[0].x, p[1].x ),
           CUBIT_MAX( p[0].y, p[1].y ),
           CUBIT_MAX( p[0].z, p[1].z ) );
  
  boundingBox.reset( min, max );

  facetLength = 0.0;
}

//===================================================================================
// 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;
	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;	
}

//-------------------------------------------------------------------------
// Purpose       : Finds the closest point on the RefEdge to the input
//                 point and modifies the coordinate values of the input
//                 point to be those of the closest point.
//
// Special Notes :
//
// Creator       : Malcolm J. Panthaki
//
// Creation Date : 2/25/97
//-------------------------------------------------------------------------
void RefEdge::move_to_curve( CubitVector& vector )
{
    // Get the Curve associated with this RefEdge
  Curve* curvePtr = this->get_curve_ptr();
  
    // Move the point to the Curve (the following call modifes the values
    // of the input "vector", if necessary)
  CubitVector closest_point;
  curvePtr->closest_point_trimmed(vector, closest_point);
  vector.set( closest_point.x(),
              closest_point.y(),
              closest_point.z() );
}

CubitStatus PartitionShell::mass_properties( CubitVector& centroid, 
                                             double& volume )
{
  PartitionCoSurf* cosurf = 0;
  DLIList<CubitFacetData*> facets;
  CubitVector p1, p2, p3, normal;
  const CubitVector p0(0.0, 0.0, 0.0);
  centroid.set(0.0, 0.0, 0.0 );
  volume = 0.0;
  
  while ((cosurf = next_co_surface( cosurf )))
  {
    if (is_nonmanifold( cosurf->get_surface() ))
      continue;
    
    facets.clean_out();
    cosurf->get_surface()->get_facet_data( facets );
    
    for (int i = facets.size(); i--; )
    {
      CubitFacet* facet = facets.step_and_get();
      p1 = facet->point(0)->coordinates();
      p2 = facet->point(1)->coordinates();
      p3 = facet->point(2)->coordinates();
      normal = (p3 - p1) * (p2 - p1);
  
      double two_area = normal.length();
      if (two_area > CUBIT_RESABS )
      {
        if (cosurf->sense() == CUBIT_REVERSED)
          normal = -normal;
        
        normal /= two_area;
        
        double height = normal % (p0 - p1);
        double vol = two_area * height;
        
        volume += vol;
        centroid += vol * (p0 + p1 + p2 + p3);
      }
    }
  }
  
  if (volume > CUBIT_RESABS)
    centroid /= 4.0 * volume;
  volume /= 6.0;
  return CUBIT_SUCCESS;
}

//-------------------------------------------------------------------------
// Purpose       : Find centroid and volume for lumps and shells
//
// Special Notes : 
//
// Author       : Jane Hu  
//
// Creation Date : 11/30/07
//-------------------------------------------------------------------------
CubitStatus OCCBody::mass_properties( CubitVector& centroid, 
                                      double& volume )
{
  if( myShells.size() == 0 && myLumps.size() == 0)
    return CUBIT_FAILURE;
  GProp_GProps myProps;
  TopoDS_Shape* pshape = myTopoDSShape;
  if(!pshape || pshape->IsNull())//single lump or shell or surface
  {
    DLIList<Lump*> lumps = this->lumps();
    if (lumps.size() > 0)
      pshape = CAST_TO(lumps.get(), OCCLump)->get_TopoDS_Solid();
  } 
  if(!pshape || pshape->IsNull())
    return CUBIT_FAILURE;
 
  BRepGProp::VolumeProperties(*pshape, myProps);
  volume = myProps.Mass();
  gp_Pnt pt = myProps.CentreOfMass(); 
  centroid.set(pt.X(), pt.Y(), pt.Z());
  return CUBIT_SUCCESS;
}

CubitStatus FacetLump::mass_properties( CubitVector& centroid, double& volume )
{
  int i;
  
  DLIList<FacetShell*> shells( myShells.size() );
  CAST_LIST( myShells, shells, FacetShell );
  assert( myShells.size() == shells.size() );
  
  DLIList<FacetSurface*> surfaces;
  DLIList<FacetShell*> surf_shells;
  get_surfaces( surfaces );
  
  DLIList<CubitFacet*> facets, surf_facets;
  DLIList<CubitPoint*> junk;
  DLIList<CubitSense> senses;
  for (i = surfaces.size(); i--; )
  {
    FacetSurface* surf = surfaces.step_and_get();
    surf_shells.clean_out();
    surf->get_shells( surf_shells );
    surf_shells.intersect( shells );
    assert( surf_shells.size() );
    CubitSense sense = surf->get_shell_sense( surf_shells.get() );
    if (surf_shells.size() == 1 && CUBIT_UNKNOWN != sense)
    {
      surf_facets.clean_out();
      junk.clean_out();
      surf->get_my_facets( surf_facets, junk );
      facets += surf_facets;
      
      for (int j = surf_facets.size(); j--; )
        senses.append(sense);
    }
  }
  
  const CubitVector p0 = bounding_box().center();
  CubitVector p1, p2, p3, normal;
  centroid.set( 0.0, 0.0, 0.0 );
  volume = 0.0;
  
  facets.reset();
  senses.reset();
  for (i = facets.size(); i--; )
  {
    CubitFacet* facet = facets.get_and_step();
    CubitSense sense = senses.get_and_step();
    p1 = facet->point(0)->coordinates();
    p2 = facet->point(1)->coordinates();
    p3 = facet->point(2)->coordinates();
    normal = (p3 - p1) * (p2 - p1);

    double two_area = normal.length();
    if (two_area > CUBIT_RESABS )
    {
      if (CUBIT_REVERSED == sense)
        normal = -normal;

      normal /= two_area;

      double height = normal % (p0 - p1);
      double vol = two_area * height;

      volume += vol;
      centroid += vol * (p0 + p1 + p2 + p3);
    }
  }
  
  if (volume > CUBIT_RESABS)
    centroid /= 4.0 * volume;
  volume /= 6.0;
  return CUBIT_SUCCESS;
}

//===================================================================================
// 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;

	//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;
}

CubitStatus
SimplifyTool::weighted_average_normal(RefFace* ref_face,
                                      CubitVector &normal, 
                                      double &weight )
{
    GMem g_mem;
    unsigned short norm_tol = 30;
    double dist_tol = -1.0;

    ref_face->get_geometry_query_engine()->
        get_graphics(ref_face->get_surface_ptr(), &g_mem, norm_tol, dist_tol );

    if(g_mem.fListCount < 1)
    {
        // Decrease tolerance and try again (we can get this for small features)
        norm_tol /= 2;
        ref_face->get_geometry_query_engine()->
            get_graphics(ref_face->get_surface_ptr(), &g_mem, norm_tol, dist_tol );
    }

    if(g_mem.fListCount < 1)
    {
        // Lets give up 
        PRINT_ERROR( "Unable to find average normal of a surface\n" );
        return CUBIT_FAILURE;
    }

    // Initialize
    weight = 0.0;
    normal.set( 0.0, 0.0, 0.0 );

    // Loop through the triangles
    double tri_weight, A, B, C;
    GPoint p[3];
    GPoint* plist = g_mem.point_list();
    int* facet_list = g_mem.facet_list();
    int c = 0;
    for( ;c<g_mem.fListCount; )
    {
        p[0] = plist[facet_list[++c]];
        p[2] = plist[facet_list[++c]];
        p[1] = plist[facet_list[++c]]; 
        c++;

        // Get centroid
        CubitVector p1( p[0].x, p[0].y, p[0].z );
        CubitVector p2( p[2].x, p[2].y, p[2].z );
        CubitVector p3( p[1].x, p[1].y, p[1].z );

        CubitVector center = (p1 + p2 + p3)/3.0;

        CubitVector norm(ref_face->normal_at(center));

        // Get triangle area
        A = p1.y() * p2.z() + p1.z() * p3.y() + p2.y() * p3.z() -
            p2.z() * p3.y() - p1.y() * p3.z() - p1.z() * p2.y();

        B = p1.z() * p2.x() + p1.x() * p3.z() + p2.z() * p3.x() -
            p2.x() * p3.z() - p1.z() * p3.x() - p1.x() * p2.z();

        C = p1.x() * p2.y() + p1.y() * p3.x() + p2.x() * p3.y() -
            p2.y() * p3.x() - p1.x() * p3.y() - p1.y() * p2.x();

        //Note: triangle area = 0.5*(sqrt(A*A+B*B+C*C));

        tri_weight = 0.5*(A*A+B*B+C*C);

        normal += tri_weight * norm;

        weight += tri_weight;

    }

    normal.normalize();

    return CUBIT_SUCCESS;
}