//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
TEST(ArrayTest, CopyConvertedData)
{
// Double array to float
{
DoubleArray ad;
ad.resize(4);
ad[0] = 0.0;
ad[1] = 1.0;
ad[2] = 2.0;
ad[3] = 3.0;
// Copy full array
FloatArray af;
af.resize(4);
af.copyConvertedData(ad, 4, 0, 0);
EXPECT_FLOAT_EQ(0.0f, af[0]);
EXPECT_FLOAT_EQ(1.0f, af[1]);
EXPECT_FLOAT_EQ(2.0f, af[2]);
EXPECT_FLOAT_EQ(3.0f, af[3]);
// Copy partial array to float array
af.resize(2);
af.setAll(0);
af.copyConvertedData(ad, 2, 0, 1);
EXPECT_FLOAT_EQ(1.0f, af[0]);
EXPECT_FLOAT_EQ(2.0f, af[1]);
}
// Vec3d to Vec3f and Vec3i
{
Vec3dArray ad;
ad.resize(2);
ad[0].set(1.1, 2.5, 3.9);
ad[1].set(11.1, 12.5, 13.9);
Vec3fArray af;
af.resize(2);
af.copyConvertedData(ad, 2, 0, 0);
EXPECT_FLOAT_EQ(1.1f, af[0].x());
EXPECT_FLOAT_EQ(2.5f, af[0].y());
EXPECT_FLOAT_EQ(3.9f, af[0].z());
EXPECT_FLOAT_EQ(11.1f, af[1].x());
EXPECT_FLOAT_EQ(12.5f, af[1].y());
EXPECT_FLOAT_EQ(13.9f, af[1].z());
Array<Vec3i> ai;
ai.resize(2);
ai.copyConvertedData(ad, 2, 0, 0);
EXPECT_EQ(1, ai[0].x());
EXPECT_EQ(2, ai[0].y());
EXPECT_EQ(3, ai[0].z());
EXPECT_EQ(11, ai[1].x());
EXPECT_EQ(12, ai[1].y());
EXPECT_EQ(13, ai[1].z());
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void BoundingBox::add(const Vec3dArray& points)
{
size_t i;
for (i = 0; i < points.size(); i++)
{
add(points[i]);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
TEST(ArrayTest, resize)
{
// Vec3f array
Vec3dArray vA;
vA.resize(4);
ASSERT_EQ(4u, vA.size());
vA[0] = Vec3d(1,2,3);
vA[1] = Vec3d(1.1, 2.2, 3.3);
vA[2] = Vec3d(0,0,0);
vA[3] = Vec3d(4,5,6);
vA.resize(5);
vA[4] = Vec3d(9.9, 0, 3.5);
ASSERT_EQ(5u, vA.size());
ASSERT_EQ(true, vA[0] == Vec3d(1,2,3));
ASSERT_EQ(true, vA[4] == Vec3d(9.9,0,3.5));
vA.resize(3);
ASSERT_EQ(3u, vA.size());
ASSERT_EQ(true, vA[0] == Vec3d(1, 2, 3));
ASSERT_EQ(true, vA[1] == Vec3d(1.1, 2.2, 3.3));
ASSERT_EQ(true, vA[2] == Vec3d(0, 0, 0));
}
// Fr. Uebele
Vec3dArray *HfT_osg_Plugin01_ParametricSurface::digitalize(double u, double v, int i)
{
Vec3dArray *feld = new Vec3dArray();
if (i == 1)
{
HlVector F = mp_ParserSurface->f(u, v);
Vec3 pkt = Vec3(F.mX, F.mY, F.mZ);
HlVector Fu = mp_ParserSurface->dfu(u, v);
Vec3 pointU = Vec3(Fu.mX, Fu.mY, Fu.mZ);
HlVector Fv = mp_ParserSurface->dfv(u, v);
Vec3 pointV = Vec3(Fv.mX, Fv.mY, Fv.mZ);
HlVector Fuv = mp_ParserSurface->dfuv(u, v);
Vec3 pointUV = Vec3(Fuv.mX, Fuv.mY, Fuv.mZ);
HlVector Fuu = mp_ParserSurface->dfuu(u, v);
Vec3 pointUU = Vec3(Fuu.mX, Fuu.mY, Fuu.mZ);
HlVector Fvv = mp_ParserSurface->dfvv(u, v);
Vec3 pointVV = Vec3(Fvv.mX, Fvv.mY, Fvv.mZ);
HlVector N = Fu.kreuzprodukt(Fv);
Vec3 pointN = Vec3(N.mX, N.mY, N.mZ);
feld->push_back(pkt);
feld->push_back(pointU);
feld->push_back(pointV);
feld->push_back(pointUV);
feld->push_back(pointUU);
feld->push_back(pointVV);
feld->push_back(pointN);
}
else
{
double K = mp_ParserSurface->K(u, v);
double H = mp_ParserSurface->H(u, v);
double E = mp_ParserSurface->E(u, v);
double F = mp_ParserSurface->F(u, v);
double G = mp_ParserSurface->G(u, v);
double L = mp_ParserSurface->L(u, v);
double M = mp_ParserSurface->M(u, v);
double N = mp_ParserSurface->N(u, v);
double EG_FF = mp_ParserSurface->EG_FF(u, v);
feld->push_back(Vec3d(K, H, E));
feld->push_back(Vec3d(F, G, L));
feld->push_back(Vec3d(M, N, EG_FF));
}
return feld;
}
//--------------------------------------------------------------------------------------------------
/// Classify where the points are located relative to the plane
///
/// \param points Points to test for location relative the plane
///
/// \return Plane::FRONT if points are either Plane::FRONT or Plane::ON\n
/// Plane::BACK if points are either Plane::BACK or Plane::ON\n
/// Plane::ON if all points are Plane::ON\n
/// Plane::BOTH if points are located on both sides
//--------------------------------------------------------------------------------------------------
Plane::Side Plane::side(const Vec3dArray& points) const
{
// Code taken from
// http://code.google.com/p/papervision3d/source/browse/trunk/as3/trunk/src/org/papervision3d/core/math/util/ClassificationUtil.as
cvf::uint frontCount = 0;
cvf::uint backCount = 0;
for (size_t i = 0; i < points.size(); i++)
{
Side s = side(points[i]);
if (s == FRONT)
{
frontCount++;
}
else if (s == BACK)
{
backCount++;
}
}
if (frontCount > 0 && backCount == 0)
{
return FRONT;
}
else if (frontCount == 0 && backCount > 0)
{
return BACK;
}
else if (frontCount > 0 && backCount > 0)
{
return BOTH;
}
else
{
return ON;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
TEST(ArrayTest, BasicVec3dArray)
{
// Vec3f array
Vec3dArray vA;
vA.resize(4);
ASSERT_EQ(4u, vA.size());
vA[0] = Vec3d(1,2,3);
vA[1] = Vec3d(1.1, 2.2, 3.3);
vA[2] = Vec3d(0,0,0);
vA[3] = Vec3d(4,5,6);
ASSERT_EQ(true, vA[0] == Vec3d(1, 2, 3));
ASSERT_EQ(true, vA[1] == Vec3d(1.1, 2.2, 3.3));
ASSERT_EQ(true, vA[2] == Vec3d(0, 0, 0));
ASSERT_EQ(true, vA[3] == Vec3d(4, 5, 6));
const double* pf = vA.ptr()->ptr();
ASSERT_DOUBLE_EQ(1.0, pf[0]);
ASSERT_DOUBLE_EQ(2.0, pf[1]);
ASSERT_DOUBLE_EQ(3.0, pf[2]);
ASSERT_DOUBLE_EQ(1.1, pf[3]);
ASSERT_DOUBLE_EQ(2.2, pf[4]);
ASSERT_DOUBLE_EQ(3.3, pf[5]);
ASSERT_DOUBLE_EQ(0.0, pf[6]);
ASSERT_DOUBLE_EQ(0.0, pf[7]);
ASSERT_DOUBLE_EQ(0.0, pf[8]);
ASSERT_DOUBLE_EQ(4.0, pf[9]);
ASSERT_DOUBLE_EQ(5.0, pf[10]);
ASSERT_DOUBLE_EQ(6.0, pf[11]);
vA.clear();
ASSERT_EQ(0u, vA.size());
}
Array* Array_readLocalData(Input& fr)
{
if (fr[0].matchWord("Use"))
{
if (fr[1].isString())
{
Object* obj = fr.getObjectForUniqueID(fr[1].getStr());
if (obj)
{
fr+=2;
return dynamic_cast<Array*>(obj);
}
}
osg::notify(osg::WARN)<<"Warning: invalid uniqueID found in file."<<std::endl;
return NULL;
}
std::string uniqueID;
if (fr[0].matchWord("UniqueID") && fr[1].isString())
{
uniqueID = fr[1].getStr();
fr += 2;
}
int entry = fr[0].getNoNestedBrackets();
const char* arrayName = fr[0].getStr();
unsigned int capacity = 0;
fr[1].getUInt(capacity);
++fr;
fr += 2;
Array* return_array = 0;
if (strcmp(arrayName,"ByteArray")==0)
{
ByteArray* array = new ByteArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
int int_value;
if (fr[0].getInt(int_value))
{
++fr;
array->push_back(int_value);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"ShortArray")==0)
{
ShortArray* array = new ShortArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
int int_value;
if (fr[0].getInt(int_value))
{
++fr;
array->push_back(int_value);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"IntArray")==0)
{
IntArray* array = new IntArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
int int_value;
if (fr[0].getInt(int_value))
{
++fr;
array->push_back(int_value);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"UByteArray")==0)
{
UByteArray* array = new UByteArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned int uint_value;
if (fr[0].getUInt(uint_value))
{
++fr;
array->push_back(uint_value);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"UShortArray")==0)
{
UShortArray* array = new UShortArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned int uint_value;
if (fr[0].getUInt(uint_value))
{
++fr;
array->push_back(uint_value);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"UIntArray")==0)
{
UIntArray* array = new UIntArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned int uint_value;
if (fr[0].getUInt(uint_value))
{
++fr;
array->push_back(uint_value);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"UVec4bArray")==0 || strcmp(arrayName,"Vec4ubArray")==0)
{
Vec4ubArray* array = new Vec4ubArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned int r,g,b,a;
if (fr[0].getUInt(r) &&
fr[1].getUInt(g) &&
fr[2].getUInt(b) &&
fr[3].getUInt(a))
{
fr+=4;
array->push_back(osg::Vec4ub(r,g,b,a));
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"FloatArray")==0)
{
FloatArray* array = new FloatArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
float float_value;
if (fr[0].getFloat(float_value))
{
++fr;
array->push_back(float_value);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"DoubleArray")==0)
{
DoubleArray* array = new DoubleArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
double double_value;
if (fr[0].getFloat(double_value))
{
++fr;
array->push_back(double_value);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec2Array")==0)
{
Vec2Array* array = new Vec2Array;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
Vec2 v;
if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()))
{
fr += 2;
array->push_back(v);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec2dArray")==0)
{
Vec2dArray* array = new Vec2dArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
Vec2d v;
if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()))
{
fr += 2;
array->push_back(v);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec3Array")==0)
{
Vec3Array* array = new Vec3Array;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
Vec3 v;
if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()) && fr[2].getFloat(v.z()))
{
fr += 3;
array->push_back(v);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec3dArray")==0)
{
Vec3dArray* array = new Vec3dArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
Vec3d v;
if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()) && fr[2].getFloat(v.z()))
{
fr += 3;
array->push_back(v);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec4Array")==0)
{
Vec4Array* array = new Vec4Array;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
Vec4 v;
if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()) && fr[2].getFloat(v.z()) && fr[3].getFloat(v.w()))
{
fr += 4;
array->push_back(v);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec4dArray")==0)
{
Vec4dArray* array = new Vec4dArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
Vec4d v;
if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()) && fr[2].getFloat(v.z()) && fr[3].getFloat(v.w()))
{
fr += 4;
array->push_back(v);
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec2bArray")==0)
{
Vec2bArray* array = new Vec2bArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned int r,g;
if (fr[0].getUInt(r) &&
fr[1].getUInt(g))
{
fr+=2;
array->push_back(osg::Vec2b(r,g));
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec3bArray")==0)
{
Vec3bArray* array = new Vec3bArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned int r,g,b;
if (fr[0].getUInt(r) &&
fr[1].getUInt(g) &&
fr[2].getUInt(b))
{
fr+=3;
array->push_back(osg::Vec3b(r,g,b));
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec4bArray")==0)
{
Vec4bArray* array = new Vec4bArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned int r,g,b,a;
if (fr[0].getUInt(r) &&
fr[1].getUInt(g) &&
fr[2].getUInt(b) &&
fr[3].getUInt(a))
{
fr+=4;
array->push_back(osg::Vec4b(r,g,b,a));
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec2sArray")==0)
{
Vec2sArray* array = new Vec2sArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned int r,g;
if (fr[0].getUInt(r) &&
fr[1].getUInt(g))
{
fr+=2;
array->push_back(osg::Vec2s(r,g));
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec3sArray")==0)
{
Vec3sArray* array = new Vec3sArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned int r,g,b;
if (fr[0].getUInt(r) &&
fr[1].getUInt(g) &&
fr[2].getUInt(b))
{
fr+=3;
array->push_back(osg::Vec3s(r,g,b));
}
else ++fr;
}
++fr;
return_array = array;
}
else if (strcmp(arrayName,"Vec4sArray")==0)
{
Vec4sArray* array = new Vec4sArray;
array->reserve(capacity);
while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
{
unsigned int r,g,b,a;
if (fr[0].getUInt(r) &&
fr[1].getUInt(g) &&
fr[2].getUInt(b) &&
fr[3].getUInt(a))
{
fr+=4;
array->push_back(osg::Vec4s(r,g,b,a));
}
else ++fr;
}
++fr;
return_array = array;
}
if (return_array)
{
if (!uniqueID.empty()) fr.registerUniqueIDForObject(uniqueID.c_str(),return_array);
}
return return_array;
}
