void split(QuadraticBezier& left, QuadraticBezier& right) const
    {
        left.control = midPoint(start, control);
        right.control = midPoint(control, end);
        
        FloatPoint leftControlToRightControl = midPoint(left.control, right.control);
        left.end = leftControlToRightControl;
        right.start = leftControlToRightControl;

        left.start = start;
        right.end = end;
    }
示例#2
0
void refine(int depth, triangle t, float** p) {
    if (depth == n) {
        t.dump(p);
    } else {
        vector3 m1 = midPoint(t.p2, t.p3).normalize();
        vector3 m2 = midPoint(t.p3, t.p1).normalize();
        vector3 m3 = midPoint(t.p1, t.p2).normalize();
        refine(depth + 1, triangle(t.p1, m3, m2), p);
        refine(depth + 1, triangle(m3, t.p2, m1), p);
        refine(depth + 1, triangle(m1, m2, m3), p);
        refine(depth + 1, triangle(m2, m1, t.p3), p);
    }
}
示例#3
0
/**
 * Arrow class contructor, that creates and arrow from a start item
 * to the endItem
 * @param startItem
 * @param endItem
 * @param parentGroup
 */
Arrow::Arrow(DocBlock *startItem, Block *endItem, BlockGroup *parentGroup)
    : QGraphicsLineItem(parentGroup)
{
    Q_ASSERT(startItem != 0);Q_ASSERT(endItem != 0);Q_ASSERT(parentGroup != 0);
    myStartItem = startItem;
    myEndItem = endItem;
    myColor = Qt::black;
    setPen(QPen(myColor, 0, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
    connect(myStartItem, SIGNAL(destroyed()), this, SLOT(deleteLater()));
    connect(myEndItem, SIGNAL(destroyed()), this, SLOT(deleteLater()));
    connect(myEndItem, SIGNAL(visibilityChanged(bool)), this, SLOT(updateVisibility(bool)));

    line1 = QLineF(startPoint(), midPoint());
    line2 = QLineF(midPoint(), endPoint());
}
示例#4
0
bool Beats::detected()
{
	bool beatDetected = false;
	
	if (	currentValue() > midPoint()
		&&	lastValue() < midPoint()
		&&	currentDerivative() > derivativeMidPoint()
		&&	currentDerivative() > derivativeLimit
		&&	beatCanTrigger())
	{
		beatDetected = true;
		iterationCounter = 1;
	}
	
	return beatDetected;
}
void Hypergraph::kdPartition (int depth, int targetDepth, vector<fvec>::iterator &firstPt, vector<fvec>::iterator &lastPt, 
							  vector<float> &divisions, int divisionIdx)
{
	if (depth>targetDepth)
	{
		return;
	}

	int nPoints = lastPt-firstPt;
	int nMidPoint = nPoints/2;
	int coord = depth%2;
	switch (coord)
	{
	case 0:
		nth_element(firstPt, firstPt+nMidPoint, lastPt, compareX);
		break;
	case 1:
		nth_element(firstPt, firstPt+nMidPoint, lastPt, compareY);
		break;
	}

	fvec &midPoint = *(firstPt+nMidPoint);
	divisions[divisionIdx] = midPoint(coord%2);
	kdPartition(depth+1, targetDepth, firstPt, firstPt+nMidPoint, divisions, 2*divisionIdx+1);
	kdPartition(depth+1, targetDepth, firstPt+nMidPoint, lastPt, divisions, 2*divisionIdx+2);
}
示例#6
0
/**
* Subdivide triangle into 4 smaller triangles
*/
vector<Vec9f> Triangle::forceSubdivide(Vec9f triangle){
	//final list
	vector<Vec9f> triangle_list;
	
	vector<cv::Point3d> vertices = convVec9fToPoint3d(triangle);
	
      //Get the mid points of each of the segments	
      cv::Point3d p01, p12, p02;
      p01 = midPoint(vertices[0], vertices[1]);
      p12 = midPoint(vertices[1], vertices[2]);
      p02 = midPoint(vertices[0], vertices[2]);
      
      // Lower left sub-triangle
    vector<cv::Point3d> tri0; Vec9f tri0f;
    tri0.push_back(vertices[0]);
    tri0.push_back(p01);
    tri0.push_back(p02);
    tri0f = convPoint3dToVec9f(tri0);
    triangle_list.push_back(tri0f);

    // top sub-triangle
    vector<cv::Point3d> tri1;Vec9f tri1f;
    tri1.push_back(p01);
    tri1.push_back(vertices[1]);
    tri1.push_back(p12);
    tri1f = convPoint3dToVec9f(tri1);
    triangle_list.push_back(tri1f);

    // Lower right sub-triangle
    vector<cv::Point3d> tri2;Vec9f tri2f;
    tri2.push_back(p02);
    tri2.push_back(p12);
    tri2.push_back(vertices[2]);
    tri2f = convPoint3dToVec9f(tri2);
    triangle_list.push_back(tri2f);

    // center sub-triangle
    vector<cv::Point3d> tri3;Vec9f tri3f;
    tri3.push_back(p01);
    tri3.push_back(p12);
    tri3.push_back(p02);
    tri3f = convPoint3dToVec9f(tri3);
    triangle_list.push_back(tri3f);
    
    return triangle_list;
}
示例#7
0
void ofApp::sierpinsky(ofVec2f a, ofVec2f b, ofVec2f c, int level) {
	if (level == 0) {
		points.push_back(a);
		points.push_back(b);
		points.push_back(c);
		return;
	}
	else {
		ofVec2f ab = midPoint(a, b);
		ofVec2f bc = midPoint(b, c);
		ofVec2f ca = midPoint(c, a);
		sierpinsky(a, ab, ca, level - 1);
		sierpinsky(ab, b, bc, level - 1);
		sierpinsky(ca, bc, c, level - 1);
	}
	drawFigure(points, TRIANGLE);
}
示例#8
0
/*
 * Subdivide one triangle to four triangles when it has angles to the center are larger than 45.0 dereees.
 */
vector< vector<cv::Point3d> >
Triangle::subdivide(vector<cv::Point3d> vertices){
  double max_angle = getMaxAngle(vertices);

  vector < vector<cv::Point3d> > triangle_list;
  cv::Point3d p01, p12, p02;
  if(max_angle > m_MAX_ANGLE){
    if(vertices.size() == 3){
      p01 = midPoint(vertices[0], vertices[1]);
      p12 = midPoint(vertices[1], vertices[2]);
      p02 = midPoint(vertices[0], vertices[2]);
    }

    // Lower left sub-triangle
    vector<cv::Point3d> tri0;
    tri0.push_back(vertices[0]);
    tri0.push_back(p01);
    tri0.push_back(p02);
    triangle_list.push_back(tri0);

    // top sub-triangle
    vector<cv::Point3d> tri1;
    tri1.push_back(p01);
    tri1.push_back(vertices[1]);
    tri1.push_back(p12);
    triangle_list.push_back(tri1);

    // Lower right sub-triangle
    vector<cv::Point3d> tri2;
    tri2.push_back(p02);
    tri2.push_back(p12);
    tri2.push_back(vertices[2]);
    triangle_list.push_back(tri2);

    // center sub-triangle
    vector<cv::Point3d> tri3;
    tri3.push_back(p01);
    tri3.push_back(p12);
    tri3.push_back(p02);
    triangle_list.push_back(tri3);
  }else{
    triangle_list.push_back(vertices);
  }

  return triangle_list;
}
示例#9
0
void structures2() {
    Point pt;
    
    pt.x = 100.0;
    pt.y = 75.0;
    
    Point mid = midPoint(pt);
    printf("Mid is %f, %f\n", mid.x, mid.y);
}
/*
 * getMidPoint
 *
 * parameter p0 - int
 * parameter p1 - int
 * return - float *
 */
float * BoundingBox::getMidPoint(int p0, int p1) {
	float * point0;
	float * point1;
	float * point;
	point0 = getCorner(p0);
	point1 = getCorner(p1);
	point = midPoint(point0, point1);
	delete[] point0;
	delete[] point1;
	return point;
} // end getMidPoint()
示例#11
0
/**
 * Paints the specified arrow
 * @return the end point
 */
void Arrow::paint(QPainter *painter, const QStyleOptionGraphicsItem *,
                  QWidget *)
{
//    if (myStartItem->collidesWithItem(myEndItem)) return;

    QPen myPen = pen();
    myPen.setColor(myColor);
    qreal arrowSize = 10;
    painter->setPen(myPen);
    painter->setBrush(myColor);

    setLine(QLineF(startPoint(), endPoint()));

    line1 = QLineF(startPoint(), midPoint());
    line2 = QLineF(midPoint(), endPoint());

    double angle = acos(line1.dx() / line1.length());

    if (line1.dy() >= 0)
        angle = (Pi * 2) - angle;

    QPointF arrowP1 = line1.p1() + QPointF(sin(angle + Pi / 3) * arrowSize,
                                            cos(angle + Pi / 3) * arrowSize);
    QPointF arrowP2 = line1.p1() + QPointF(sin(angle + Pi - Pi / 3) * arrowSize,
                                            cos(angle + Pi - Pi / 3) * arrowSize);

    //arrow corner
    cornerLine1= QLineF(endPoint(),endPoint()+QPointF(0,10));
    cornerLine2= QLineF(endPoint(),endPoint()-QPointF(10,0));

    arrowHead.clear();
    arrowHead << line1.p1() << arrowP1 << arrowP2;
    painter->setRenderHint(QPainter::Antialiasing);
    painter->drawLine(line1);
    painter->drawLine(line2);
    painter->drawLine(cornerLine1);
     painter->drawLine(cornerLine2);
    painter->drawPolygon(arrowHead);
}
示例#12
0
//---------------------------------------------------------
// Spliting them into 4 smaller triangles
//----------------------------------------------------------
void subDivideTriangles(int level, std::vector<TriangleIndices> *facesIn,  std::vector<TriangleIndices> *facesOut, std::vector<STVector3> *vertices)
{
    std::multimap<long, int> midPointIndices;
    int nFaces = facesIn->size();

    for (int i = 0; i < level; i++) {
        
          for(int j = 0; j < (int)facesIn->size(); ++j) {

              int a = midPoint((*facesIn)[j].i1, (*facesIn)[j].i2, &midPointIndices, vertices);
              int b = midPoint((*facesIn)[j].i2, (*facesIn)[j].i3, &midPointIndices, vertices);
              int c = midPoint((*facesIn)[j].i3, (*facesIn)[j].i1, &midPointIndices, vertices);

              facesOut->push_back(makeTIndices((*facesIn)[j].i1, a, c));
              facesOut->push_back(makeTIndices((*facesIn)[j].i2, b, a));
              facesOut->push_back(makeTIndices((*facesIn)[j].i3, c, b));
              facesOut->push_back(makeTIndices(a, b, c));
          }
          (*facesIn) = (*facesOut);
          nFaces=facesIn->size();
    }
}
void BezierCurveEvaluator::divide(Point P[], Point L[], Point R[]) const
{
	L[0] = P[0];
	L[1] = midPoint(P[0], P[1]);
	Point H = midPoint(P[1], P[2]);
	L[2] = midPoint(L[1], H);
	
	R[3] = P[3];
	R[2] = midPoint(P[2], P[3]);
	R[1] = midPoint(P[2], H);
	R[0] = midPoint(L[2], R[1]);
	L[3] = R[0];
}
示例#14
0
int binarySearchJval(Jval *a, Jval item, int low, int high, int (*compare)(Jval*, Jval*)) {
	int mid = midPoint(low, high);
	int res;

	if(low > high) {
		return -1;
	}

	res = compare(&a[mid], &item);
	if(res > 0) {
		return binarySearchJval(a, item, low, mid - 1, compare);
	}

	if(res < 0) {
		return binarySearchJval(a, item, mid + 1, high, compare);
	}

	return mid;
}
示例#15
0
bool QgsGeometryUtils::segmentMidPoint( const QgsPointV2& p1, const QgsPointV2& p2, QgsPointV2& result, double radius, const QgsPointV2& mousePos )
{
  QgsPointV2 midPoint(( p1.x() + p2.x() ) / 2.0, ( p1.y() + p2.y() ) / 2.0 );
  double midDist = sqrt( sqrDistance2D( p1, midPoint ) );
  if ( radius < midDist )
  {
    return false;
  }
  double centerMidDist = sqrt( radius * radius - midDist * midDist );
  double dist = radius - centerMidDist;

  double midDx = midPoint.x() - p1.x();
  double midDy = midPoint.y() - p1.y();

  //get the four possible midpoints
  QList<QgsPointV2> possibleMidPoints;
  possibleMidPoints.append( pointOnLineWithDistance( midPoint, QgsPointV2( midPoint.x() - midDy, midPoint.y() + midDx ), dist ) );
  possibleMidPoints.append( pointOnLineWithDistance( midPoint, QgsPointV2( midPoint.x() - midDy, midPoint.y() + midDx ), 2 * radius - dist ) );
  possibleMidPoints.append( pointOnLineWithDistance( midPoint, QgsPointV2( midPoint.x() + midDy, midPoint.y() - midDx ), dist ) );
  possibleMidPoints.append( pointOnLineWithDistance( midPoint, QgsPointV2( midPoint.x() + midDy, midPoint.y() - midDx ), 2 * radius - dist ) );

  //take the closest one
  double minDist = std::numeric_limits<double>::max();
  int minDistIndex = -1;
  for ( int i = 0; i < possibleMidPoints.size(); ++i )
  {
    double currentDist = sqrDistance2D( mousePos, possibleMidPoints.at( i ) );
    if ( currentDist < minDist )
    {
      minDistIndex = i;
      minDist = currentDist;
    }
  }

  if ( minDistIndex == -1 )
  {
    return false;
  }

  result = possibleMidPoints.at( minDistIndex );
  return true;
}
 void split(CubicBezier& left, CubicBezier& right) const
 {    
     FloatPoint startToControl1 = midPoint(control1, control2);
     
     left.start = start;
     left.control1 = midPoint(start, control1);
     left.control2 = midPoint(left.control1, startToControl1);
     
     right.control2 = midPoint(control2, end);
     right.control1 = midPoint(right.control2, startToControl1);
     right.end = end;
     
     FloatPoint leftControl2ToRightControl1 = midPoint(left.control2, right.control1);
     left.end = leftControl2ToRightControl1;
     right.start = leftControl2ToRightControl1;
 }
示例#17
0
void problem18() {
	GLubyte black[] = {0,0,0};
	glm::vec3 v1(100,200,1), v2(200,300,1), v3(300,200,1);

	glm::mat3 mat(0.5, 0, 0,
			      0, 0.5, 0,
			      0, 0, 1);
	glm::vec3 midPoint(((v1.x + v2.x + v3.x) / 3.0), ((v1.y + v2.y + v3.y) / 3.0), 1);
	
	v1 -= midPoint;
	v2 -= midPoint;
	v3 -= midPoint;
	
	v1 = mat * v1;
	v2 = mat * v2;
	v3 = mat * v3;
	
	v1 += midPoint;
	v2 += midPoint;
	v3 += midPoint;
	drawTriangle(v1,v2,v3, black);
}
      void 
      createNewElements(percept::PerceptMesh& eMesh, NodeRegistry& nodeRegistry, 
                        stk::mesh::Entity& element,  NewSubEntityNodesType& new_sub_entity_nodes, vector<stk::mesh::Entity *>::iterator& element_pool,
                        stk::mesh::FieldBase *proc_rank_field=0)
      {
        const CellTopologyData * const cell_topo_data = stk::percept::PerceptMesh::get_cell_topology(element);
        typedef boost::tuple<stk::mesh::EntityId, stk::mesh::EntityId> line_tuple_type;
        static vector<line_tuple_type> elems(2);

        CellTopology cell_topo(cell_topo_data);
        const stk::mesh::PairIterRelation elem_nodes = element.relations(stk::mesh::fem::FEMMetaData::NODE_RANK);

        std::vector<stk::mesh::Part*> add_parts;
        std::vector<stk::mesh::Part*> remove_parts;

        add_parts = m_toParts;
        
        unsigned num_nodes_on_edge = new_sub_entity_nodes[m_eMesh.edge_rank()][0].size();
        if (!num_nodes_on_edge)
          return;

        double coord_x[3];
        for (int iedge = 0; iedge < 1; iedge++)
          {
            //double * mp = midPoint(EDGE_COORD(iedge,0), EDGE_COORD(iedge,1), eMesh.get_spatial_dim(), coord_x);
            //double * mp = midPoint(FACE_COORD(iedge,0), FACE_COORD(iedge,1), eMesh.get_spatial_dim(), coord_x);
            double * mp = midPoint(VERT_COORD(0), VERT_COORD(1), eMesh.get_spatial_dim(), coord_x);

            if (!EDGE_N(iedge))
              {
                std::cout << "P[" << eMesh.get_rank() << " nid ## = 0  " << std::endl;
              }

            eMesh.createOrGetNode(EDGE_N(iedge), mp);
          }

        // FIXME
        nodeRegistry.makeCentroidCoords(*const_cast<stk::mesh::Entity *>(&element), m_primaryEntityRank, 0u);
        nodeRegistry.addToExistingParts(*const_cast<stk::mesh::Entity *>(&element), m_primaryEntityRank, 0u);

        nodeRegistry.interpolateFields(*const_cast<stk::mesh::Entity *>(&element), m_primaryEntityRank, 0u);

        Elem::CellTopology elem_celltopo = Elem::getCellTopology< FromTopology >();
        const Elem::RefinementTopology* ref_topo_p = Elem::getRefinementTopology(elem_celltopo);
        const Elem::RefinementTopology& ref_topo = *ref_topo_p;

#ifndef NDEBUG
        unsigned num_child = ref_topo.num_child();
        VERIFY_OP(num_child, == , 2, "createNewElements num_child problem");
        bool homogeneous_child = ref_topo.homogeneous_child();
        VERIFY_OP(homogeneous_child, ==, true, "createNewElements homogeneous_child");
#endif

        // new_sub_entity_nodes[i][j]
        //const UInt * const * child_nodes() const {
        //const UInt * child_node_0 = ref_topo.child_node(0);

        typedef Elem::StdMeshObjTopologies::RefTopoX RefTopoX;
        RefTopoX& l2 = Elem::StdMeshObjTopologies::RefinementTopologyExtra< FromTopology > ::refinement_topology;

#define CENTROID_N NN(m_primaryEntityRank,0)  

        for (unsigned iChild = 0; iChild < 2; iChild++)
          {
            unsigned EN[2];
            for (unsigned jNode = 0; jNode < 2; jNode++)
              {
                unsigned childNodeIdx = ref_topo.child_node(iChild)[jNode];
#ifndef NDEBUG
                unsigned childNodeIdxCheck = l2[childNodeIdx].ordinal_of_node;
                VERIFY_OP(childNodeIdx, ==, childNodeIdxCheck, "childNodeIdxCheck");
#endif
                unsigned inode=0;

                if (l2[childNodeIdx].rank_of_subcell == 0)
                  inode = VERT_N(l2[childNodeIdx].ordinal_of_subcell);
                else if (l2[childNodeIdx].rank_of_subcell == 1)
                  inode = EDGE_N(l2[childNodeIdx].ordinal_of_subcell);

                //                 else if (l2[childNodeIdx].rank_of_subcell == 2)
                //                   inode = CENTROID_N;

                EN[jNode] = inode;
              }
            elems[iChild] = line_tuple_type(EN[0], EN[1]);
          }

#undef CENTROID_N

        for (unsigned ielem=0; ielem < elems.size(); ielem++)
          {
            stk::mesh::Entity& newElement = *(*element_pool);

#if 0
            if (proc_rank_field && proc_rank_field->rank() == m_eMesh.edge_rank()) //&& m_eMesh.get_spatial_dim()==1)
              {
                double *fdata = stk::mesh::field_data( *static_cast<const ScalarFieldType *>(proc_rank_field) , newElement );
                //fdata[0] = double(m_eMesh.get_rank());
                fdata[0] = double(newElement.owner_rank());
              }
#endif
            stk::mesh::FieldBase * proc_rank_field_edge = m_eMesh.get_field("proc_rank_edge");
            if (proc_rank_field_edge)
              {
                double *fdata = stk::mesh::field_data( *static_cast<const ScalarFieldType *>(proc_rank_field_edge) , newElement );
                fdata[0] = double(newElement.owner_rank());
                //fdata[0] = 1234.56;
                if (0)
                std::cout << "P[" << m_eMesh.get_rank() << "] tmp set proc_rank_field_edge to value = " << newElement.owner_rank() 
                          << " for side element = " << newElement.identifier()
                          << std::endl;
              }

            //eMesh.get_bulk_data()->change_entity_parts( newElement, add_parts, remove_parts );

            change_entity_parts(eMesh, element, newElement);

            {
              if (!elems[ielem].get<0>())
                {
                  std::cout << "P[" << eMesh.get_rank() << " nid = 0  " << std::endl;
                  exit(1);
                }

            }

            eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<0>()), 0);
            eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<1>()), 1);

            set_parent_child_relations(eMesh, element, newElement, ielem);

            element_pool++;

          }

      }
void MyPrimitive::GenerateCone(float a_fRadius, float a_fHeight, int a_nSubdivisions, vector3 a_v3Color)
{
	if (a_nSubdivisions < 3)
		a_nSubdivisions = 3;
	if (a_nSubdivisions > 360)
		a_nSubdivisions = 360;

	Release();
	Init();

	//Your code starts here
	vector3 topPoint(0.00f, a_fHeight / 2, 0.00f); //top vertex
	vector3 midPoint(0.00f, -(a_fHeight / 2), 0.00f); //mid-base vertex
	std::vector<vector3> basePoints; //base vertices
	for (int x = 0; x < a_nSubdivisions; x++)
	{
		//calculate vertex positions
		float angle = ((2 * PI) / a_nSubdivisions) * x;
		float x_Value = a_fRadius * sin(angle);
		float z_Value = a_fRadius * cos(angle);

		basePoints.push_back(vector3(x_Value, -(a_fHeight / 2), z_Value));
	}
	//create cone
	for (int x = 0; x < basePoints.size(); x++)
	{
		AddVertexPosition(topPoint);
		AddVertexPosition(basePoints[x]);
		if (x == basePoints.size() - 1)
		{
			AddVertexPosition(basePoints[0]);
		}
		else
		{
			AddVertexPosition(basePoints[x + 1]);
		}
	}
	//create base
	for (int x = 0; x < basePoints.size(); x++)
	{
		AddVertexPosition(midPoint);
		if (x == basePoints.size() - 1)
		{
			AddVertexPosition(basePoints[0]);
		}
		else
		{
			AddVertexPosition(basePoints[x + 1]);
		}
		AddVertexPosition(basePoints[x]);
	}

	//float fValue = 0.5f;
	////3--2
	////|  |
	////0--1
	//vector3 point0(-fValue, -fValue, fValue); //0
	//vector3 point1(fValue, -fValue, fValue); //1
	//vector3 point2(fValue, fValue, fValue); //2
	//vector3 point3(-fValue, fValue, fValue); //3

	//AddQuad(point0, point1, point3, point2);

	//Your code ends here
	CompileObject(a_v3Color);
}
示例#20
0
void FindCircle::imageCallback(const sensor_msgs::ImageConstPtr& msg) {
    if (image->bpp != msg->step / msg->width || image->width != msg->width || image->height != msg->height) {
        delete image;
        ROS_DEBUG("Readjusting image format from %ix%i %ibpp, to %ix%i %ibpp.", image->width, image->height, image->bpp, msg->width, msg->height, msg->step / msg->width);
        image = new CRawImage(msg->width, msg->height, msg->step / msg->width);
    }

    memcpy(image->data, (void*) &msg->data[0], msg->step * msg->height);

    circle_detection::detection_results_array tracked_objects;
    tracked_objects.header = msg->header;
    visualization_msgs::MarkerArray marker_list;
	
	std::vector<STrackedObject> circles;
	
    //search image for circles
    for (int i = 0; i < MAX_PATTERNS; i++) {
        SSegment lastSegment = currentSegmentArray[i];
//         currentSegmentArray[i] = detectorArray[i]->findSegment(image, lastSegment);
        currentSegmentArray[i] = detectorArray[i]->findSegment(image, lastSegment);
        if (currentSegmentArray[i].valid) {
			STrackedObject sTrackedObject = trans->transform(currentSegmentArray[i]);
			// Filter error values
			if (isnan(sTrackedObject.x)) continue;
			if (isnan(sTrackedObject.y)) continue;
			if (isnan(sTrackedObject.z)) continue;
			if (isnan(sTrackedObject.roll)) continue;
			if (isnan(sTrackedObject.pitch)) continue;
			if (isnan(sTrackedObject.yaw)) continue;

			circles.push_back(sTrackedObject);
		}
	}
	
// 	std::cout << "found " << circles.size() << " circles\n";
	
	// Early rejection if the candidate circles are just not enough
	if (circles.size()<NUM_CIRCLES) {
		return;
	}
	
	// Search for the nearest circle to predefined center point (3D)
	const int nearestIx = nearest3DObjIx(circles,SEARCH_X,SEARCH_Y,SEARCH_Z);
	
	// Search for the knn (k=5) of the nearest point
	std::vector<std::pair<int,double> > knn = knn3DObjIx(circles,circles[nearestIx].x,circles[nearestIx].y,circles[nearestIx].z);

// 	Early rejection if the candidate circles are just not enough
// 	if (knn.size()<NUM_CIRCLES) {
// 		std::cout << "Not enough circles! " << knn.size() << std::endl;
// 		return;
// 	}
	
	std::vector<STrackedObject> knnCircles;
    for (int i = 0; i < NUM_CIRCLES; i++) {
		knnCircles.push_back(circles[knn[i].first]);
    }
	
	std::pair<int,int> firstAndThirdCircles = largestDistIndices(knnCircles); // The first and third circles
	std::pair<float,float> midXYFirstAndThird = midPoint(knnCircles, firstAndThirdCircles); // The middle point between first and third circles
	std::pair<float,float> midXYRef = midPoint(knnCircles); // The middle point of the 5 points
	double refAngle = angleBetweenPts(midXYFirstAndThird,midXYRef) - 0.5*M_PI ; // The reference line 
	if (refAngle<0) refAngle += ONE_ROUND_RADIAN; // Turn it to [0, 2PI)
//     std::cout << refAngle/M_PI*180 << std::endl;
	
	for (std::vector<STrackedObject>::iterator it=knnCircles.begin(); it!=knnCircles.end(); ++it) {
		double angleToRef = angleBetweenPts(
			std::pair<float,float>(it->segment.x,it->segment.y),midXYRef) - refAngle;
		it->segment.angleToRef = (angleToRef>=0)? angleToRef : angleToRef+ONE_ROUND_RADIAN;
	}
	
	// Sort the detected circles according to the angle to reference line
	std::sort(knnCircles.begin(),knnCircles.end(),circlePositionCompare);
	
	// Turn it back to [-PI, PI)
	const double angle_offset = refAngle>ONE_ROUND_RADIAN/2 ? refAngle-ONE_ROUND_RADIAN : refAngle ;

// 	/*
	// Sanity check: compare the second line's orientation
	// Get the angle from 3rd circle to 4th circle
	double angle_0to2 = angleBetweenPts(
		std::pair<float,float>((knnCircles.begin())->segment.x,(knnCircles.begin())->segment.y),
		std::pair<float,float>((knnCircles.begin()+2)->segment.x,(knnCircles.begin()+2)->segment.y)
	);
	double angle_4to3 = angleBetweenPts(
		std::pair<float,float>((knnCircles.begin()+4)->segment.x,(knnCircles.begin()+4)->segment.y),
		std::pair<float,float>((knnCircles.begin()+3)->segment.x,(knnCircles.begin()+3)->segment.y)
	);
	if (abs(angle_0to2-angle_4to3)>ANGLE_THRLD_RATE) {
		std::cout << "lines doesn't allign!" << std::endl;
		return;
	}
// 	*/
	
	int i =0;
	int personId = 0;
	for (std::vector<STrackedObject>::iterator it=knnCircles.begin(); it!=knnCircles.end(); ++it) {
		double angle = ((it->segment.angle-angle_offset)/M_PI+1)/2*numCommands;
		int digit = (int)(floor(angle+0.5)+2) % numCommands;
		personId += digit * pow(4,i);
		
// 		std::cout << i << ": " << it->segment.angleToRef/M_PI*180 << " " << it->segment.bwRatio << " " << digit << std::endl;
		
		// temp value to hold current detection
		circle_detection::detection_results objectsToAdd;

		// Convert to ROS standard Coordinate System
		objectsToAdd.pose.position.x = -(*it).y;
		objectsToAdd.pose.position.y = -(*it).z;
		objectsToAdd.pose.position.z = (*it).x;
		// Convert YPR to Quaternion
		tf::Quaternion q;
		q.setRPY((*it).roll, (*it).pitch, (*it).yaw);
		objectsToAdd.pose.orientation.x = q.getX();
		objectsToAdd.pose.orientation.y = q.getY();
		objectsToAdd.pose.orientation.z = q.getZ();
		objectsToAdd.pose.orientation.w = q.getW();

		// This needs to be replaced with a unique label as ratio is unreliable
		objectsToAdd.bwratio = (*it).bwratio;
		objectsToAdd.circleId = i++;
		objectsToAdd.digit = digit;

		// Hardcoded values need to be replaced
		objectsToAdd.objectsize.x = 3;
		objectsToAdd.objectsize.y = 3;
		objectsToAdd.objectsize.z = 0;

		tracked_objects.tracked_objects.push_back(objectsToAdd);		
	}

	tracked_objects.personId = personId;
	
	if(tracked_objects.tracked_objects.size()!=NUM_CIRCLES) {
		return;
    }

    if (tracked_objects.tracked_objects.size() > 0) {
		std::cout << "publish: " << personId <<std::endl;
		std::cout << "--" << std::endl;
        pub.publish(tracked_objects);
    }
    memcpy((void*) &msg->data[0], image->data, msg->step * msg->height);
    imdebug.publish(msg);
}
示例#21
0
int main(int argc, char *argv[])
{

    if (argc != 10 || !strncmp(argv[1],"-h",2))
    {
        puts("DrawLineSegment: Prints a line through two given points");
        puts("USAGE: ./DrawLineSegment x");
        return 0;
    }

    initscr();			/* Start curses mode 		*/
    raw();				/* Line buffering disabled	*/
    noecho();			/* Don't echo() while we do getch */

    start_color();			/* Start color 			*/
    init_pair(1, COLOR_RED, COLOR_RED);
    init_pair(2, COLOR_BLUE, COLOR_BLUE);
    attron(COLOR_PAIR(1));
    curs_set(0);

    double x1 = atof(argv[1]);
    double y1 = atof(argv[2]);

    double x2 = atof(argv[3]);
    double y2 = atof(argv[4]);

    double x3 = atof(argv[5]);
    double y3 = atof(argv[6]);

    double x4 = atof(argv[7]);
    double y4 = atof(argv[8]);

    Pair mid1 = midPoint(x1,y1,x2,y2);
    Pair mid2 = midPoint(x3,y3,x4,y4);
    Pair mid = midPoint(mid1.x,mid1.y,mid2.x,mid2.y);

    Pair rpoint1;
    Pair rpoint2;
    Pair rpoint3;
    Pair rpoint4;

    for (int i = 0; i < 1080; i++)
    {
        rpoint1 = rotateDPoint(mid.x,mid.y,x1,y1,i);
        rpoint2 = rotateDPoint(mid.x,mid.y,x2,y2,i);
        rpoint3 = rotateDPoint(mid.x,mid.y,x3,y3,i);
        rpoint4 = rotateDPoint(mid.x,mid.y,x4,y4,i);

        //draw the starting line

        //draw the midpoint
        attron(COLOR_PAIR(2));
        drawPair(mid);

        //draw rotated about the middle point
        attron(COLOR_PAIR(1));
        drawQuadrilateral(rpoint1.x,rpoint1.y,
                          rpoint2.x,rpoint2.y,
                          rpoint3.x,rpoint3.y,
                          rpoint4.x,rpoint4.y); //draw the shape

        refresh(); /* Print it on to the real screen */
        //sleep() wasn't working too well for me
        for (int j = 0; j <= atol(argv[5])*10000; j++);
        clear();
    }
    getch();			/* Wait for user input */
    endwin();			/* End curses mode		  */

    return 0;
}
      void 
      createNewElements(percept::PerceptMesh& eMesh, NodeRegistry& nodeRegistry, 
                        stk::mesh::Entity& element,  NewSubEntityNodesType& new_sub_entity_nodes, vector<stk::mesh::Entity *>::iterator& element_pool,
                        stk::mesh::FieldBase *proc_rank_field=0)
      {
        const CellTopologyData * const cell_topo_data = stk::percept::PerceptMesh::get_cell_topology(element);
        typedef boost::tuple<stk::mesh::EntityId, stk::mesh::EntityId, stk::mesh::EntityId, stk::mesh::EntityId> quad_tuple_type;
        static vector<quad_tuple_type> elems(4);

        CellTopology cell_topo(cell_topo_data);
        const stk::mesh::PairIterRelation elem_nodes = element.relations(stk::mesh::fem::FEMMetaData::NODE_RANK);

        //stk::mesh::Part & active = mesh->ActivePart();
        //stk::mesh::Part & quad4  = mesh->QuadPart();

        std::vector<stk::mesh::Part*> add_parts;
        std::vector<stk::mesh::Part*> remove_parts;

        //add_parts.push_back( &active );
        //FIXME 
        //add_parts.push_back( const_cast<mesh::Part*>( eMesh.getPart(m_toTopoPartName) ));
        add_parts = m_toParts;
        
        double tmp_x[3];
        for (int iedge = 0; iedge < 4; iedge++)
          {
            double * mp = midPoint(EDGE_COORD(iedge,0), EDGE_COORD(iedge,1), eMesh.get_spatial_dim(), tmp_x);

            if (!EDGE_N(iedge))
              {
                std::cout << "P[" << eMesh.get_rank() << " nid ## = 0 << " << std::endl;
              }
            eMesh.createOrGetNode(EDGE_N(iedge), mp);

          }

        nodeRegistry.makeCentroidCoords(*const_cast<stk::mesh::Entity *>(&element), m_eMesh.element_rank(), 0u);


// new_sub_entity_nodes[i][j]
#define CENTROID_N NN(m_primaryEntityRank,0)  

        elems[0] = quad_tuple_type(VERT_N(0), EDGE_N(0), CENTROID_N, EDGE_N(3));
        elems[1] = quad_tuple_type(VERT_N(1), EDGE_N(1), CENTROID_N, EDGE_N(0));
        elems[2] = quad_tuple_type(VERT_N(2), EDGE_N(2), CENTROID_N, EDGE_N(1));
        elems[3] = quad_tuple_type(VERT_N(3), EDGE_N(3), CENTROID_N, EDGE_N(2));

#undef CENTROID_N

        // write a diagram of the refinement pattern as a vtk file, or a latex/tikz/pgf file
#define WRITE_DIAGRAM 0
#if WRITE_DIAGRAM

#endif
        
        for (unsigned ielem=0; ielem < elems.size(); ielem++)
          {
            stk::mesh::Entity& newElement = *(*element_pool);

            if (proc_rank_field)
              {
                double *fdata = stk::mesh::field_data( *static_cast<const ScalarFieldType *>(proc_rank_field) , newElement );
                //fdata[0] = double(m_eMesh.get_rank());
                fdata[0] = double(newElement.owner_rank());
              }

            eMesh.get_bulk_data()->change_entity_parts( newElement, add_parts, remove_parts );

            {
              if (!elems[ielem].get<0>())
                {
                  std::cout << "P[" << eMesh.get_rank() << " nid = 0 << " << std::endl;
                  exit(1);
                }

            }
            eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<0>()), 0);
            eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<1>()), 1);
            eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<2>()), 2);
            eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<3>()), 3);

            set_parent_child_relations(eMesh, element, newElement, ielem);


            element_pool++;

          }

      }
示例#23
0
void 
simpleFluidEmitter::omniFluidEmitter(
	MFnFluid& 		fluid,
	const MMatrix&	fluidWorldMatrix,
	int 			plugIndex,
	MDataBlock& 	block,
	double 			dt,
	double			conversion,
	double			dropoff
)
//==============================================================================
//
//	Method:	
//
//		simpleFluidEmitter::omniFluidEmitter
//
//	Description:
//
//		Emits fluid from a point, or from a set of object control points.
//
//	Parameters:
//
//		fluid:				fluid into which we are emitting
//		fluidWorldMatrix:	object->world matrix for the fluid
//		plugIndex:			identifies which fluid connected to the emitter
//							we are emitting into
//		block:				datablock for the emitter, to retrieve attribute
//							values
//		dt:					time delta for this frame
//		conversion:			mapping from UI emission rates to internal units
//		dropoff:			specifies how much emission rate drops off as
//							we move away from each emission point.
//
//	Notes:
//
//		If no owner object is present for the emitter, we simply emit from
//		the emitter position.  If an owner object is present, then we emit
//		from each control point of that object in an identical fashion.
//		
//		To associate an owner object with an emitter, use the
//		addDynamic MEL command, e.g. "addDynamic simpleFluidEmitter1 pPlane1".
//
//==============================================================================
{
	//	find the positions that we need to emit from
	//
	MVectorArray emitterPositions;
	
	//	first, try to get them from an owner object, which will have its
	//	"ownerPositionData" attribute feeding into the emitter.  These
	//	values are in worldspace
	//
	bool gotOwnerPositions = false;
	MObject ownerShape = getOwnerShape();
	if( ownerShape != MObject::kNullObj )
	{
		MStatus status;
		MDataHandle hOwnerPos = block.inputValue( mOwnerPosData, &status );
		if( status == MS::kSuccess )
		{
			MObject dOwnerPos = hOwnerPos.data();
			MFnVectorArrayData fnOwnerPos( dOwnerPos );
			MVectorArray posArray = fnOwnerPos.array( &status );
			if( status == MS::kSuccess )
			{
				// assign vectors from block to ownerPosArray.
				//
				for( unsigned int i = 0; i < posArray.length(); i ++ )
				{
					emitterPositions.append( posArray[i] );
				}
				
				gotOwnerPositions = true;
			}
		}
	}
	
	//	there was no owner object, so we just use the emitter position for
	//	emission.
	//
	if( !gotOwnerPositions )
	{
		MPoint emitterPos = getWorldPosition();
		emitterPositions.append( emitterPos );
	}

	//	get emission rates for density, fuel, heat, and emission color
	//	
	double densityEmit = fluidDensityEmission( block );
	double fuelEmit = fluidFuelEmission( block );
	double heatEmit = fluidHeatEmission( block );
	bool doEmitColor = fluidEmitColor( block );
	MColor emitColor = fluidColor( block );

	//	rate modulation based on frame time, user value conversion factor, and
	//	standard emitter "rate" value (not actually exposed in most fluid
	//	emitters, but there anyway).
	//
	double theRate = getRate(block) * dt * conversion;

	//	get voxel dimensions and sizes (object space)
	//
	double size[3];
	unsigned int res[3];
	fluid.getDimensions( size[0], size[1], size[2] );
	fluid.getResolution( res[0], res[1], res[2] );
	
	//	voxel sizes
	double dx = size[0] / res[0];
	double dy = size[1] / res[1];
	double dz = size[2] / res[2];
	
	//	voxel centers
	double Ox = -size[0]/2;
	double Oy = -size[1]/2;
	double Oz = -size[2]/2;	

	//	emission will only happen for voxels whose centers lie within
	//	"minDist" and "maxDist" of an emitter position
	//
	double minDist = getMinDistance( block );
	double maxDist = getMaxDistance( block );

	//	bump up the min/max distance values so that they
	//	are both > 0, and there is at least about a half
	//	voxel between the min and max values, to prevent aliasing
	//	artifacts caused by emitters missing most voxel centers
	//
	MTransformationMatrix fluidXform( fluidWorldMatrix );
	double fluidScale[3];
	fluidXform.getScale( fluidScale, MSpace::kWorld );
	
	//	compute smallest voxel diagonal length
	double wsX =  fabs(fluidScale[0]*dx);
	double wsY = fabs(fluidScale[1]*dy);
	double wsZ = fabs(fluidScale[2]*dz);
	double wsMin = MIN( MIN( wsX, wsY), wsZ );
	double wsMax = MAX( MAX( wsX, wsY), wsZ );
	double wsDiag  = wsMin * sqrt(3.0);

	//	make sure emission range is bigger than 0.5 voxels
	if ( maxDist <= minDist || maxDist <= (wsDiag/2.0) ) {
		if ( minDist < 0 ) minDist = 0;

		maxDist = minDist + wsDiag/2.0;
		dropoff = 0;
	}

	//	Now, it's time to actually emit into the fluid:
	//	
	//	foreach emitter point
	//		foreach voxel
	//			- select some points in the voxel
	//			- compute a dropoff function from the emitter point
	//			- emit an appropriate amount of fluid into the voxel
	//
	//	Since we've already expanded the min/max distances to cover
	//	the smallest voxel dimension, we should only need 1 sample per
	//	voxel, unless the voxels are highly non-square.  We increase the
	//	number of samples in these cases.
	//
	//	If the "jitter" flag is enabled, we jitter each sample position,
	//	using the rangen() function, which keeps track of independent 
	//	random states for each fluid, to make sure that results are
	//	repeatable for multiple simulation runs.
	//	

	// basic sample count
	int numSamples = 1;

	// increase samples if necessary for non-square voxels
	if(wsMin >.00001) 
	{
		numSamples = (int)(wsMax/wsMin + .5);
		if(numSamples > 8) 
			numSamples = 8;
		if(numSamples < 1)
			numSamples = 1;
	}
	
	bool jitter =  fluidJitter(block);
	if( !jitter )
	{
		//	I don't have a good uniform sample generator for an 
		//	arbitrary number of samples.  It would be a good idea to use
		//	one here.  For now, just use 1 sample for the non-jittered case.
		//
		numSamples = 1;
	}

	for( unsigned int p = 0; p < emitterPositions.length(); p++ )
	{
		MPoint emitterWorldPos = emitterPositions[p];

		//	loop through all voxels, looking for ones that lie at least
		//	partially within the dropoff field around this emitter point
		//
		for( unsigned int i = 0; i < res[0]; i++ )
		{
			double x = Ox + i*dx;
			
			for( unsigned int j = 0; j < res[1]; j++ )
			{
				double y = Oy + j*dy;
				
				for( unsigned int k = 0; k < res[2]; k++ )
				{
					double z = Oz + k*dz;
	
					int si;
					for( si = 0; si < numSamples; si++ )
					{
						//	compute sample point (fluid object space)
						//
						double rx, ry, rz;
						if( jitter )
						{
							rx = x + randgen()*dx;
							ry = y + randgen()*dy;
							rz = z + randgen()*dz;
						}
						else
						{
							rx = x + 0.5*dx;
							ry = y + 0.5*dy;
							rz = z + 0.5*dz;
						}

						//	compute distance from sample to emitter point
						//	
						MPoint point( rx, ry, rz );
						point *= fluidWorldMatrix;
						MVector diff = point - emitterWorldPos;
						double distSquared = diff * diff;
						double dist = diff.length();
					
						//	discard if outside min/max range
						//
						if( (dist < minDist) || (dist > maxDist) )
						{
							continue;
						}
						
						//	drop off the emission rate according to the falloff
						//	parameter, and divide to accound for multiple samples
						//	in the voxel
						//
						double distDrop = dropoff * distSquared;
						double newVal = theRate * exp( -distDrop ) / (double)numSamples;

						//	emit density/heat/fuel/color into the current voxel
						//
						if( newVal != 0 )
						{
							fluid.emitIntoArrays( (float) newVal, i, j, k, (float)densityEmit, (float)heatEmit, (float)fuelEmit, doEmitColor, emitColor );
						}

						float *fArray = fluid.falloff();
						if( fArray != NULL )
						{
							MPoint midPoint( x+0.5*dx, y+0.5*dy, z+0.5*dz );
							midPoint.x *= 0.2;
							midPoint.y *= 0.2;
							midPoint.z *= 0.2;

							float fdist = (float) sqrt( midPoint.x*midPoint.x + midPoint.y*midPoint.y + midPoint.z*midPoint.z );
							fdist /= sqrtf(3.0f);
							fArray[fluid.index(i,j,k)] = 1.0f-fdist;
						}
					}
				}
			}
		}
	}
}
示例#24
0
文件: KdNode.cpp 项目: latuya23/rt2
KdNode* KdNode::buildTree(std::vector<Triangle*>& tris, int depth) {
  KdNode* node = new KdNode();
  node->m_triangles = tris;
  node->leftChild = NULL;
  node->rightChild = NULL;
  node->m_boxBV = new Box();
  //node->Print();

  if (tris.size() == 0){
    return node;
  }
  if (tris.size() == 1) {
    node->m_boxBV = tris[0]->m_boxBV;
    node->leftChild = new KdNode();
    node->rightChild = new KdNode();
    node->leftChild->m_triangles = std::vector<Triangle*>();
    node->rightChild->m_triangles = std::vector<Triangle*>();
    return node;
  }

  //get box surrounding all triangles
  //node->m_boxBV = tris[0]->m_boxBV;
  for (unsigned int i=0; i < tris.size(); i++){
    node->m_boxBV = node->m_boxBV->Union(*(tris[i]->m_boxBV));
  }
  glm::dvec3 midPoint(0.0);
  for (unsigned int i = 0; i < tris.size(); i++){
    //find midpoint of all triangles
    midPoint = midPoint + (tris[i]->m_boxBV->Center() * (1.0 / tris.size()));
  }
  std::vector<Triangle*> left_tris;
  std::vector<Triangle*> right_tris;
  int axis = node->m_boxBV->MaxExtent();
  for(unsigned int i=0; i < tris.size();i++){
    //split triangles based on their midpoints avg
    switch(axis){
      case 0://x axis
	if (midPoint.x >= tris[i]->m_boxBV->Center().x){
	  right_tris.push_back(tris[i]);
	}
	else{
	  left_tris.push_back(tris[i]);
	}
      case 1:// y axis
	if (midPoint.y >= tris[i]->m_boxBV->Center().y){
	  right_tris.push_back(tris[i]);
	}
	else{
	  left_tris.push_back(tris[i]);
	}
      case 2:// z axis
	if (midPoint.z >= tris[i]->m_boxBV->Center().z){
	  right_tris.push_back(tris[i]);
	}
	else{
	  left_tris.push_back(tris[i]);
	}
    }
  }
  if (left_tris.empty() && !right_tris.empty()){
    left_tris = right_tris;
  }
  if (right_tris.empty() && !left_tris.empty()){
    right_tris = left_tris;
  }
  int matches = 0;
  for (unsigned int i=0; i < left_tris.size(); i++){
    for (unsigned int j=0; j < right_tris.size();j++){
      if (left_tris[i] == right_tris[i]){
	matches++;
      }
    }
  }
  if ((float)matches / left_tris.size() < .5 &&
      (float)matches / right_tris.size() < .5) {
    node->leftChild = buildTree(left_tris, depth+1);
    node->rightChild = buildTree(right_tris, depth+1);
    //std::cout << "depth: " << depth << std::endl;
  }
  else{
    node->leftChild = new KdNode();
    node->rightChild = new KdNode();
    node->leftChild->m_triangles = std::vector<Triangle*>();
    node->rightChild->m_triangles = std::vector<Triangle*>();
  }
  //node->Print();
  return node;  
}
      void 
      createNewElements(percept::PerceptMesh& eMesh, NodeRegistry& nodeRegistry, 
                        stk_classic::mesh::Entity& element,  NewSubEntityNodesType& new_sub_entity_nodes, vector<stk_classic::mesh::Entity *>::iterator& element_pool,
                        stk_classic::mesh::FieldBase *proc_rank_field=0)
      {
        const CellTopologyData * const cell_topo_data = stk_classic::percept::PerceptMesh::get_cell_topology(element);
        typedef boost::tuple<stk_classic::mesh::EntityId, stk_classic::mesh::EntityId, stk_classic::mesh::EntityId> tri_tuple_type;
        static vector<tri_tuple_type> elems(6);

        CellTopology cell_topo(cell_topo_data);
        const stk_classic::mesh::PairIterRelation elem_nodes = element.relations(stk_classic::mesh::fem::FEMMetaData::NODE_RANK);

        //stk_classic::mesh::Part & active = mesh->ActivePart();
        //stk_classic::mesh::Part & quad4  = mesh->QuadPart();

        std::vector<stk_classic::mesh::Part*> add_parts;
        std::vector<stk_classic::mesh::Part*> remove_parts;

        //add_parts.push_back( &active );
        //FIXME 
        //add_parts.push_back( const_cast<mesh::Part*>( eMesh.getPart(m_toTopoPartName) ));
        add_parts = m_toParts;
        
        /**
           \node[above] at (p4.side 1){2};
           \node[left] at (p4.side 2){3};
           \node[below] at (p4.side 3){0};
           \node[right] at (p4.side 4){1};
        */



        double tmp_x[3];
        for (int iedge = 0; iedge < 4; iedge++)
          {
            double * mp = midPoint(EDGE_COORD(iedge,0), EDGE_COORD(iedge,1), eMesh.get_spatial_dim(), tmp_x);

            if (!EDGE_N(iedge))
              {
                std::cout << "P[" << eMesh.get_rank() << " nid ## = 0 << " << std::endl;
              }
            eMesh.createOrGetNode(EDGE_N(iedge), mp);

          }


        elems[0] = tri_tuple_type(VERT_N(0), EDGE_N(0), EDGE_N(3));
        elems[1] = tri_tuple_type(VERT_N(1), EDGE_N(1), EDGE_N(0));
        elems[2] = tri_tuple_type(EDGE_N(0), EDGE_N(1), EDGE_N(3));

        elems[3] = tri_tuple_type(VERT_N(2), EDGE_N(2), EDGE_N(1));
        elems[4] = tri_tuple_type(VERT_N(3), EDGE_N(3), EDGE_N(2));
        elems[5] = tri_tuple_type(EDGE_N(2), EDGE_N(3), EDGE_N(1));

        // write a diagram of the refinement pattern as a vtk file, or a latex/tikz/pgf file
#define WRITE_DIAGRAM 0
#if WRITE_DIAGRAM

#endif
        
        for (unsigned ielem=0; ielem < elems.size(); ielem++)
          {
            //stk_classic::mesh::Entity& newElement = eMesh.get_bulk_data()->declare_entity(Element, *element_id_pool, eMesh.getPart(interface_table::shards_Triangle_3) );
            //stk_classic::mesh::Entity& newElement = eMesh.get_bulk_data()->declare_entity(Element, *element_id_pool, eMesh.getPart(interface_table::shards_Triangle_3) );

            stk_classic::mesh::Entity& newElement = *(*element_pool);

            if (proc_rank_field)
              {
                double *fdata = stk_classic::mesh::field_data( *static_cast<const ScalarFieldType *>(proc_rank_field) , newElement );
                //fdata[0] = double(m_eMesh.get_rank());
                fdata[0] = double(newElement.owner_rank());
              }

            //eMesh.get_bulk_data()->change_entity_parts( newElement, add_parts, remove_parts );
            change_entity_parts(eMesh, element, newElement);

            {
              if (!elems[ielem].get<0>())
                {
                  std::cout << "P[" << eMesh.get_rank() << " nid = 0 << " << std::endl;
                  exit(1);
                }

            }
            eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<0>()), 0);
            eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<1>()), 1);
            eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<2>()), 2);

            set_parent_child_relations(eMesh, element, newElement, ielem);


            element_pool++;

          }

      }
示例#26
0
void GuiTextEditSliderCtrl::onRender(Point2I offset, const RectI &updateRect)
{
   if(mTextAreaHit != None)
   {
      U32 elapseTime = Sim::getCurrentTime() - mMouseDownTime;
      if(elapseTime > 750 || mTextAreaHit == Slider)
      {
         timeInc(elapseTime);
         mIncCounter += mMulInc;
         if(mIncCounter >= 1.0f || mIncCounter <= -1.0f)
         {
            mValue = (mMulInc > 0.0f) ? mValue+mIncAmount : mValue-mIncAmount;
            mIncCounter = (mIncCounter > 0.0f) ? mIncCounter-1 : mIncCounter+1;
            checkRange();
            setValue();
            mCursorPos = 0;
         }
      }
   }
	Parent::onRender(offset, updateRect);

   Point2I start(offset.x + getWidth() - 14, offset.y);
   Point2I midPoint(start.x + 7, start.y + (getExtent().y/2));

   GFX->getDrawUtil()->drawRectFill(Point2I(start.x+1,start.y+1), Point2I(start.x+13,start.y+getExtent().y-1) , mProfile->mFillColor);

   GFX->getDrawUtil()->drawLine(start, Point2I(start.x, start.y+getExtent().y),mProfile->mFontColor);
   GFX->getDrawUtil()->drawLine(Point2I(start.x,midPoint.y),
               Point2I(start.x+14,midPoint.y),
               mProfile->mFontColor);

   GFXVertexBufferHandle<GFXVertexPCT> verts(GFX, 6, GFXBufferTypeVolatile);
   verts.lock();

   verts[0].color.set( 0, 0, 0 );
	verts[1].color.set( 0, 0, 0 );
	verts[2].color.set( 0, 0, 0 );
	verts[3].color.set( 0, 0, 0 );
	verts[4].color.set( 0, 0, 0 );
	verts[5].color.set( 0, 0, 0 );

   if(mTextAreaHit == ArrowUp)
   {
      verts[0].point.set( (F32)midPoint.x, (F32)start.y + 1.0f, 0.0f );
      verts[1].point.set( (F32)start.x + 11.0f, (F32)midPoint.y - 2.0f, 0.0f );
      verts[2].point.set( (F32)start.x + 3.0f, (F32)midPoint.y - 2.0f, 0.0f );
   }
   else
   {
      verts[0].point.set( (F32)midPoint.x, (F32)start.y + 2.0f, 0.0f );
      verts[1].point.set( (F32)start.x + 11.0f, (F32)midPoint.y - 1.0f, 0.0f );
      verts[2].point.set( (F32)start.x + 3.0f, (F32)midPoint.y - 1.0f, 0.0f );
   }

   if(mTextAreaHit == ArrowDown)
   {
      verts[3].point.set( (F32)midPoint.x, (F32)(start.y + getExtent().y - 1), 0.0f );
      verts[4].point.set( (F32)start.x + 11.0f, (F32)midPoint.y + 3.0f, 0.0f );
      verts[5].point.set( (F32)start.x + 3.0f, (F32)midPoint.y + 3.0f, 0.0f );
   }
   else
   {
      verts[3].point.set( (F32)midPoint.x, (F32)(start.y + getExtent().y - 2), 0.0f );
      verts[4].point.set( (F32)start.x + 11.0f, (F32)midPoint.y + 2.0f, 0.0f );
      verts[5].point.set( (F32)start.x + 3.0f, (F32)midPoint.y + 2.0f, 0.0f );
   }

   verts.unlock();

   GFX->setVertexBuffer( verts );
   GFX->setupGenericShaders();
   GFX->drawPrimitive( GFXTriangleList, 0, 2 );
}