C++ UIntArray::size方法代码示例

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
TEST(PrimitiveSetIndexedUInt, GetOpenGLPrimitive_FromTriangles)
{
    ref<UIntArray> indices = new UIntArray;
    indices->reserve(6);
    indices->add(0);  
    indices->add(1);  
    indices->add(2);
    indices->add(3);
    indices->add(4);
    indices->add(5);

    ref<PrimitiveSetIndexedUInt> myPrim = new PrimitiveSetIndexedUInt(PT_TRIANGLES);
    myPrim->setIndices(indices.p());

    ASSERT_EQ(2u, myPrim->faceCount());

    UIntArray conn;
    
    myPrim->getFaceIndices(0, &conn);
    ASSERT_EQ(3u, conn.size());
    EXPECT_EQ(0u, conn.get(0));
    EXPECT_EQ(1u, conn.get(1));
    EXPECT_EQ(2u, conn.get(2));

    myPrim->getFaceIndices(1, &conn);
    ASSERT_EQ(3u, conn.size());
    EXPECT_EQ(3u, conn.get(0));
    EXPECT_EQ(4u, conn.get(1));
    EXPECT_EQ(5u, conn.get(2));
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
bool DrawableGeo::rayIntersect(const Ray& ray, Vec3dArray* intersectionPoints, UIntArray* facesHit) const
{
    if (intersectionPoints) intersectionPoints->setSizeZero();
    if (facesHit) facesHit->setSizeZero();

    std::vector<Vec3d> isectPts;
    std::vector<uint> faceIndices;

    cref<Vec3fArray> vertexArr = m_vertexBundle->vertexArray();
    int accumulatedFaceCount = 0;

    size_t numPrimitiveSets = m_primitiveSets.size();
    size_t iPrimSet;
    for (iPrimSet = 0; iPrimSet < numPrimitiveSets; iPrimSet++)
    {
        const PrimitiveSet* primSet = m_primitiveSets.at(iPrimSet);
        CVF_TIGHT_ASSERT(primSet);

        UIntArray conn;
        int numPrimFaces = static_cast<int>(primSet->faceCount());
#pragma omp parallel for private(conn)
        for (int i = 0; i < numPrimFaces; i++)
        {
            bool hitThisFace = false;
            Vec3d localIntersect;

            primSet->getFaceIndices(static_cast<size_t>(i), &conn);
            int numconn = static_cast<int>(conn.size());
            if (numconn == 3)
            {
                hitThisFace = ray.triangleIntersect(Vec3d(vertexArr->get(conn[0])), 
                                                    Vec3d(vertexArr->get(conn[1])), 
                                                    Vec3d(vertexArr->get(conn[2])), 
                                                    &localIntersect);
            }

            if (hitThisFace)
            {
              #pragma omp critical
	      {
                isectPts.push_back(localIntersect);
                faceIndices.push_back(i + accumulatedFaceCount);
	      }
            }
        }
        accumulatedFaceCount += numPrimFaces;
    }

    if (isectPts.size() > 0)
    {
        if (intersectionPoints) intersectionPoints->assign(isectPts);
        if (facesHit) facesHit->assign(faceIndices);

        return true;
    }
    else
    {
        return false;
    }
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
TEST(ArrayTest, setConsecutiveEmpty)
{
    UIntArray arr;
    arr.setConsecutive(0);

    EXPECT_EQ(0, arr.size());
}

Beagle::MPI::GA::EvolverBitString::EvolverBitString(UIntArray inInitSize)

{
    if(inInitSize.size()==0) addOperator(new Beagle::GA::InitBitStrOp(0));
    else if(inInitSize.size()==1) addOperator(new Beagle::GA::InitBitStrOp(inInitSize[0]));
    else {
        std::ostringstream lOSS;
        lOSS << "Initialization of bit string individuals with more than one bit string ";
        lOSS << "is no more valid. You should use individuals made of one bit string, or ";
        lOSS << "define your own bit string initialization operator.";
        throw Beagle_RunTimeExceptionM(lOSS.str());
    }
    addOperator(new Beagle::GA::CrossoverOnePointBitStrOp);
    addOperator(new Beagle::GA::CrossoverTwoPointsBitStrOp);
    addOperator(new Beagle::GA::CrossoverUniformBitStrOp);
    addOperator(new Beagle::GA::MutationFlipBitStrOp);
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
TEST(MeshEdgeExtractorTest, PrimitiveMixFromFaceList)
{
    //           6----5
    //          /      \      *11
    //         /        \         *12
    // 8------7          4-----9   
    // |      |\        /      |
    // |      | \      /       |
    // 0------1--2----3       10   

    UIntArray fl;
    fl.reserve(26);

    fl.add(1);  fl.add(11);  
    fl.add(1);  fl.add(12);
    fl.add(2);  fl.add(4);  fl.add(9);  
    fl.add(2);  fl.add(10); fl.add(9);  
    fl.add(3);  fl.add(1);  fl.add(2);  fl.add(7); 
    fl.add(4);  fl.add(0);  fl.add(1);  fl.add(7);  fl.add(8); 
    fl.add(6);  fl.add(2);  fl.add(3);  fl.add(4);  fl.add(5);  fl.add(6);  fl.add(7); 
    ASSERT_EQ(26, fl.size());


    MeshEdgeExtractor ee;
    ee.addFaceList(fl);

    UIntArray li = *ee.lineIndices();
    ASSERT_EQ(2*13, li.size());

    EXPECT_EQ(0, li[ 0]);    EXPECT_EQ(1, li[ 1]);
    EXPECT_EQ(0, li[ 2]);    EXPECT_EQ(8, li[ 3]);
    EXPECT_EQ(1, li[ 4]);    EXPECT_EQ(2, li[ 5]);
    EXPECT_EQ(1, li[ 6]);    EXPECT_EQ(7, li[ 7]);
    EXPECT_EQ(2, li[ 8]);    EXPECT_EQ(3, li[ 9]);
    EXPECT_EQ(2, li[10]);    EXPECT_EQ(7, li[11]);
    EXPECT_EQ(3, li[12]);    EXPECT_EQ(4, li[13]);
    EXPECT_EQ(4, li[14]);    EXPECT_EQ(5, li[15]);
    EXPECT_EQ(4, li[16]);    EXPECT_EQ(9, li[17]);
    EXPECT_EQ(5, li[18]);    EXPECT_EQ(6, li[19]);
    EXPECT_EQ(6, li[20]);    EXPECT_EQ(7, li[21]);
    EXPECT_EQ(7, li[22]);    EXPECT_EQ(8, li[23]);
    EXPECT_EQ(9, li[24]);    EXPECT_EQ(10,li[25]);
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void OutlineEdgeExtractor::addPrimitives(uint verticesPerPrimitive, const UIntArray& indices)
{
    CVF_ASSERT(verticesPerPrimitive > 0);

    size_t indexCount = indices.size();
    size_t numPrimitives = indexCount/verticesPerPrimitive;
    if (numPrimitives > 0)
    {
        const uint* indexPtr = indices.ptr();
        addPrimitives(verticesPerPrimitive, indexPtr, indexCount);
    }
}

//--------------------------------------------------------------------------------------------------
/// Add a triangle fan
/// 
/// Vertex ordering for triangle fans:
/// <PRE>
///   v4 *-------* v3        Resulting triangles:
///       \     / \            t1: v0, v1, v2
///        \   /   \           t2: v0, v2, v3
///         \ /     \          t3: v0, v3, v4
///       v0 *-------* v2        
///           \     /
///            \   /
///             \ /
///              * v1 </PRE>
/// 
/// \remarks The number of entries in the \a indices array must be at least 3.
//--------------------------------------------------------------------------------------------------
void GeometryBuilder::addTriangleFan(const UIntArray& indices)
{
    size_t numIndices = indices.size();
    CVF_ASSERT(numIndices >= 3);

    size_t numTriangles = numIndices - 2;
    CVF_ASSERT(numTriangles >= 1);

    size_t i;
    for (i = 0; i < numTriangles; i++)
    {
        addTriangle(indices[0], indices[i + 1], indices[i + 2]);
    }
}

//--------------------------------------------------------------------------------------------------
/// Add a quad strip
/// 
/// Vertex ordering for quad strips:
/// <PRE>
///   v0    v2    v4    v6   Resulting quads:
///   *-----*-----*-----*       q1: v0, v1, v3, v2
///   |     |     |     |       q2: v2, v3, v5, v4
///   |     |     |     |       q3: v4, v5, v7, v6
///   |     |     |     |       
///   *-----*-----*-----*
///   v1    v3    v5    v7 </PRE>
/// 
/// \remarks There must be at least 4 entries in the \a indices array, and the total number of 
///          entries must be a multiple of 2.
//--------------------------------------------------------------------------------------------------
void GeometryBuilder::addQuadStrip(const UIntArray& indices)
{
    size_t numIndices = indices.size();
    CVF_ASSERT(numIndices >= 4);
    CVF_ASSERT(numIndices % 2 == 0);

    size_t numQuads = (numIndices - 2)/2;
    CVF_ASSERT(numQuads >= 1);

    size_t i;
    for (i = 0; i < numQuads; i++)
    {
        addQuad(indices[2*i], indices[2*i + 1], indices[2*i + 3], indices[2*i + 2]);
    }
}

//--------------------------------------------------------------------------------------------------
/// Add multiple triangles
/// 
/// \remarks There must be at least 3 entries in the \a indices array, and the total number of 
///          entries must be a multiple of 3.   
//--------------------------------------------------------------------------------------------------
void GeometryBuilder::addTriangles(const UIntArray& indices)
{
    size_t numIndices = indices.size();
    CVF_ASSERT(numIndices >= 3);
    CVF_ASSERT(numIndices % 3 == 0);

    size_t numTriangles = numIndices/3;
    CVF_ASSERT(numTriangles >= 1);
    CVF_ASSERT(3*numTriangles == numIndices);

    size_t i;
    for (i = 0; i < numTriangles; i++)
    {
        addTriangle(indices[3*i], indices[3*i + 1], indices[3*i + 2]);
    }
}

//--------------------------------------------------------------------------------------------------
/// Add multiple quads
/// 
/// The default implementation utilizes addQuad() to add each quad separately.
/// 
/// \remarks There must be at least 4 entries in the \a indices array, and the total number of 
///          entries must be a multiple of 4.
//--------------------------------------------------------------------------------------------------
void GeometryBuilder::addQuads(const UIntArray& indices)
{
    size_t numIndices = indices.size();
    CVF_ASSERT(numIndices >= 4);
    CVF_ASSERT(numIndices % 4 == 0);

    size_t numQuads = numIndices/4;
    CVF_ASSERT(numQuads >= 1);
    CVF_ASSERT(4*numQuads == numIndices);

    size_t i;
    for (i = 0; i < numQuads; i++)
    {
        addQuad(indices[4*i], indices[4*i + 1], indices[4*i + 2], indices[4*i + 3]);
    }
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void OutlineEdgeExtractor::addFaceList(const UIntArray& faceList)
{
    size_t numFaceListEntries = faceList.size();

    size_t i = 0;
    while (i < numFaceListEntries)
    {
        uint numVerticesInFace = faceList[i++];
        CVF_ASSERT(numVerticesInFace > 0);
        CVF_ASSERT(i + numVerticesInFace <= numFaceListEntries);

        const uint* indexPtr = &faceList[i];
        addPrimitives(numVerticesInFace, indexPtr, numVerticesInFace);

        i += numVerticesInFace;
    }
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
TEST(OutlineEdgeExtractorTest, ThreeQuads)
{
    ref<Vec3fArray> va = new Vec3fArray;
    va->reserve(8);
    va->add(Vec3f(0, 0, 0));
    va->add(Vec3f(1, 0, 0));
    va->add(Vec3f(2, 0, 0));
    va->add(Vec3f(3, 0, 0));
    va->add(Vec3f(0, 1, 0));
    va->add(Vec3f(1, 1, 0));
    va->add(Vec3f(2, 1, 0));
    va->add(Vec3f(3, 1, 0));

    // 4------5------6------7
    // |      |      |      | 
    // |      |      |      | 
    // 0------1------2------3

    OutlineEdgeExtractor ee(0, *va);

    {
        const cvf::uint conn[8] = { 0, 1, 5, 4,  1, 2, 6, 5 };
        ee.addPrimitives(4, conn, 8);
    }

    {
        const cvf::uint conn[4] = { 2, 3, 7, 6 };
        ee.addPrimitives(4, conn, 4);
    }

    UIntArray li = *ee.lineIndices();
    ASSERT_EQ(2*8, li.size());

    EXPECT_TRUE( EdgeKey(0, 1) == EdgeKey(li[ 0], li[ 1]) );
    EXPECT_TRUE( EdgeKey(0, 4) == EdgeKey(li[ 2], li[ 3]) );
    EXPECT_TRUE( EdgeKey(1, 2) == EdgeKey(li[ 4], li[ 5]) );
    EXPECT_TRUE( EdgeKey(2, 3) == EdgeKey(li[ 6], li[ 7]) );
    EXPECT_TRUE( EdgeKey(3, 7) == EdgeKey(li[ 8], li[ 9]) );
    EXPECT_TRUE( EdgeKey(4, 5) == EdgeKey(li[10], li[11]) );
    EXPECT_TRUE( EdgeKey(5, 6) == EdgeKey(li[12], li[13]) );
    EXPECT_TRUE( EdgeKey(6, 7) == EdgeKey(li[14], li[15]) );
}

//--------------------------------------------------------------------------------------------------
/// Add one face 
/// 
/// The type of primitive added will be determined from the number of indices passed in \a indices
/// 
/// \remarks Currently, points and lines are not supported. Faces with more than 4 indices will
///          be triangulated using fanning
//--------------------------------------------------------------------------------------------------
void GeometryBuilder::addFace(const UIntArray& indices)
{
    size_t numIndices = indices.size();
    CVF_ASSERT(numIndices >= 3);

    if (numIndices == 3)
    {
        addTriangle(indices[0], indices[1], indices[2]);
    }
    else if (numIndices == 4)
    {
        addQuad(indices[0], indices[1], indices[2], indices[3]);
    }
    else
    {
        size_t numTriangles = numIndices - 2;
        size_t i;
        for (i = 0; i < numTriangles; i++)
        {
            addTriangle(indices[0], indices[i + 1], indices[i + 2]);
        }
    }
}

//--------------------------------------------------------------------------------------------------
/// Sets the DrawableGeo object's geometry representation from a face list
/// 
/// \param faceList Face list
///
/// faceList contains number of items before each face connectivities. E.g. 3 0 1 2   3 2 3 1   3 2 1 3
///
/// \note This method will use more temporary memory than strictly needed in order to optimize 
///       performance.
//--------------------------------------------------------------------------------------------------
void DrawableGeo::setFromFaceList(const UIntArray& faceList)
{
    m_primitiveSets.clear();

    size_t numFaceListEntries = faceList.size();

    ref<UIntArray> triangleConnects = new UIntArray;
	triangleConnects->reserve(numFaceListEntries*3);		// Usually too much, but temporary and will be squeezed if kept.

    size_t i = 0;
    while (i < numFaceListEntries)
    {
        uint numConnects = faceList[i++];
        CVF_ASSERT(numConnects >= 3);

        if (numConnects == 3)
        {
			triangleConnects->add(faceList[i++]);
			triangleConnects->add(faceList[i++]);
			triangleConnects->add(faceList[i++]);
		}
		else 
		{
            size_t j;
            for (j = 0; j < numConnects - 2;  j++)
            {
                triangleConnects->add(faceList[i]);
                triangleConnects->add(faceList[i + 1 + j]);
                triangleConnects->add(faceList[i + 2 + j]);
            }

            i += numConnects;
		}
    }

    // Check if the largest index used in the triangle connects exceeds short representation
	if (triangleConnects->max() < std::numeric_limits<ushort>::max())
	{
		// Create an USHORT primitive set
		size_t arraySize = triangleConnects->size();

		ref<UShortArray> shortIndices = new UShortArray;
		shortIndices->resize(arraySize);

		size_t j;
		for (j = 0; j < arraySize; j++)
		{
			shortIndices->set(j, static_cast<ushort>(triangleConnects->get(j)));
		}

		ref<PrimitiveSetIndexedUShort> prim = new PrimitiveSetIndexedUShort(PT_TRIANGLES);
		prim->setIndices(shortIndices.p());

		m_primitiveSets.push_back(prim.p());
	}
	else
	{
		// Create a UINT primitive set
		ref<PrimitiveSetIndexedUInt> prim = new PrimitiveSetIndexedUInt(PT_TRIANGLES);

		triangleConnects->squeeze();
		prim->setIndices(triangleConnects.p());
		m_primitiveSets.push_back(prim.p());
	}
}