Metal1() {
fileLeft = "/apps/workspaces/kiste_data/stereo/3/left.png";
fileRight = "/apps/workspaces/kiste_data/stereo/3/right.png";
imgLeft = ImageFactory::readPNG(fileLeft);
imgRight = ImageFactory::readPNG(fileRight);
MatchingSAD sad(imgLeft, imgRight, 15);
Matching matcher;
Point2i pl1(608,834); Point2i pr1(400,873); //pr1 = matcher.refine(sad, pl1, pr1);
Point2i pl2(357,485); Point2i pr2(292,470); //pr2 = matcher.refine(sad, pl2, pr2);
Point2i pl3(461,672); Point2i pr3(294,678); //pr3 = matcher.refine(sad, pl3, pr3);
Point2i pl4(524,507); Point2i pr4(410,523); //pr4 = matcher.refine(sad, pl4, pr4);
Point2i pl5(518,479); Point2i pr5(440,493); //pr5 = matcher.refine(sad, pl5, pr5);
Point2i pl6(586,405); Point2i pr6(476,431); //pr6 = matcher.refine(sad, pl6, pr6);
Point2i pl7(593,324); Point2i pr7(532,349); //pr7 = matcher.refine(sad, pl7, pr7);
Point2i pl8(673,366); Point2i pr8(596,405); //pr8 = matcher.refine(sad, pl8, pr8);
fm.addCorrespondence(pl1, pr1);
fm.addCorrespondence(pl2, pr2);
fm.addCorrespondence(pl3, pr3);
fm.addCorrespondence(pl4, pr4);
fm.addCorrespondence(pl5, pr5);
fm.addCorrespondence(pl6, pr6);
fm.addCorrespondence(pl7, pr7);
fm.addCorrespondence(pl8, pr8);
//fm.addCorrespondence(pl9, pr9);
fm.estimate();
}
House1() {
fileLeft = "/apps/workspaces/kiste_data/stereo/4/left.png";
fileRight = "/apps/workspaces/kiste_data/stereo/4/right.png";
imgLeft = ImageFactory::readPNG(fileLeft);
imgRight = ImageFactory::readPNG(fileRight);
MatchingSAD sad(imgLeft, imgRight, 15);
Matching matcher;
Point2i pl1(110,244); Point2i pr1(198,296); //pr1 = matcher.refine(sad, pl1, pr1);
Point2i pl2(273,242); Point2i pr2(309,249); //pr2 = matcher.refine(sad, pl2, pr2);
Point2i pl3(88,117); Point2i pr3(129,121); //pr3 = matcher.refine(sad, pl3, pr3);
Point2i pl4(247,122); Point2i pr4(244,89); //pr4 = matcher.refine(sad, pl4, pr4);
Point2i pl5(321,100); Point2i pr5(320,50); //pr5 = matcher.refine(sad, pl5, pr5);
Point2i pl6(398,162); Point2i pr6(428,125); //pr6 = matcher.refine(sad, pl6, pr6);
Point2i pl7(393,282); Point2i pr7(424,273); //pr7 = matcher.refine(sad, pl7, pr7);
Point2i pl8(266,154); Point2i pr8(278,132); //pr8 = matcher.refine(sad, pl8, pr8);
fm.addCorrespondence(pl1, pr1);
fm.addCorrespondence(pl2, pr2);
fm.addCorrespondence(pl3, pr3);
fm.addCorrespondence(pl4, pr4);
fm.addCorrespondence(pl5, pr5);
fm.addCorrespondence(pl6, pr6);
fm.addCorrespondence(pl7, pr7);
fm.addCorrespondence(pl8, pr8);
//fm.addCorrespondence(pl9, pr9);
fm.estimate();
}
IDIS() {
fileLeft = "/apps/workspaces/kiste_data/stereo/2/left.png";
fileRight = "/apps/workspaces/kiste_data/stereo/2/right.png";
imgLeft = ImageFactory::readPNG(fileLeft);
imgRight = ImageFactory::readPNG(fileRight);
MatchingSAD sad(imgLeft, imgRight, 15);
Matching matcher;
Point2i pl1(257,369); Point2i pr1(98,367); pr1 = matcher.refine(sad, pl1, pr1);
Point2i pl2(261,579); Point2i pr2(101,589); pr2 = matcher.refine(sad, pl2, pr2);
Point2i pl3(282,692); Point2i pr3(121,708); pr3 = matcher.refine(sad, pl3, pr3);
Point2i pl4(657,673); Point2i pr4(520,678); pr4 = matcher.refine(sad, pl4, pr4);
Point2i pl5(704,247); Point2i pr5(569,247); pr5 = matcher.refine(sad, pl5, pr5);
Point2i pl6(816,641); Point2i pr6(679,641); pr6 = matcher.refine(sad, pl6, pr6);
Point2i pl7(1113,503); Point2i pr7(964,501); pr7 = matcher.refine(sad, pl7, pr7);
Point2i pl8(1025,472); Point2i pr8(882,472); pr8 = matcher.refine(sad, pl8, pr8);
Point2i pl9(1096,345); Point2i pr9(948,348); pr9 = matcher.refine(sad, pl9, pr9);
fm.addCorrespondence(pl1, pr1);
fm.addCorrespondence(pl2, pr2);
fm.addCorrespondence(pl3, pr3);
fm.addCorrespondence(pl4, pr4);
fm.addCorrespondence(pl5, pr5);
fm.addCorrespondence(pl6, pr6);
fm.addCorrespondence(pl7, pr7);
fm.addCorrespondence(pl8, pr8);
//fm.addCorrespondence(pl9, pr9);
fm.estimate();
}
House3D() {
fileLeft = "/apps/workspaces/kiste_data/stereo/5/left.png";
fileRight = "/apps/workspaces/kiste_data/stereo/5/right.png";
imgLeft = ImageFactory::readPNG(fileLeft);
imgRight = ImageFactory::readPNG(fileRight);
// imgLeft = Derivative::getX(imgLeft);
// imgRight = Derivative::getX(imgRight);
// Normalize::inplace(imgLeft);
// Normalize::inplace(imgRight);
MatchingSAD sad(imgLeft, imgRight, 15);
Matching matcher;
Point2i pl1(245,381); Point2i pr1(176,366); //pr1 = matcher.refine(sad, pl1, pr1); // h1 lower left
Point2i pl2(308,323); Point2i pr2(312,323); //pr2 = matcher.refine(sad, pl2, pr2); // h1 lower right
Point2i pl3(222,82); Point2i pr3(246,82); //pr3 = matcher.refine(sad, pl3, pr3); // h1 upper right
Point2i pl4(134,76); Point2i pr4(101,78); //pr4 = matcher.refine(sad, pl4, pr4); // h1 upper left
Point2i pl5(501,218); Point2i pr5(416,228); //pr5 = matcher.refine(sad, pl5, pr5); // h1 mid left
Point2i pl6(620,201); Point2i pr6(625,219); //pr6 = matcher.refine(sad, pl6, pr6); // h1 mid right
Point2i pl7(546,83); Point2i pr7(570,78); //pr7 = matcher.refine(sad, pl7, pr7); // h1 upper right
Point2i pl8(423,79); Point2i pr8(378,77); //pr8 = matcher.refine(sad, pl8, pr8); // h1 upper left
Point2i pl9(381,413); Point2i pr9(319,420); //pr8 = matcher.refine(sad, pl8, pr8); // cube1a
Point2i plA(153,322); Point2i prA(68,299); //pr8 = matcher.refine(sad, pl8, pr8); // cube2
Point2i plB(348,361); Point2i prB(294,362); //pr8 = matcher.refine(sad, pl8, pr8); // cube1b
// Point2i pl1(242,219); Point2i pr1(171,212); //pr1 = matcher.refine(sad, pl1, pr1); // h1 lower left
// Point2i pl2(307,194); Point2i pr2(311,194); //pr2 = matcher.refine(sad, pl2, pr2); // h1 lower right
// Point2i pl3(222,82); Point2i pr3(246,82); //pr3 = matcher.refine(sad, pl3, pr3); // h1 upper right
// Point2i pl4(134,76); Point2i pr4(101,78); //pr4 = matcher.refine(sad, pl4, pr4); // h1 upper left
// Point2i pl5(501,218); Point2i pr5(416,228); //pr5 = matcher.refine(sad, pl5, pr5); // h1 lower left
// Point2i pl6(620,201); Point2i pr6(625,219); //pr6 = matcher.refine(sad, pl6, pr6); // h1 lower right
// Point2i pl7(546,83); Point2i pr7(570,78); //pr7 = matcher.refine(sad, pl7, pr7); // h1 upper right
// Point2i pl8(423,79); Point2i pr8(378,77); //pr8 = matcher.refine(sad, pl8, pr8); // h1 upper left
fm.addCorrespondence(pl1, pr1);
fm.addCorrespondence(pl2, pr2);
fm.addCorrespondence(pl3, pr3);
fm.addCorrespondence(pl4, pr4);
fm.addCorrespondence(pl5, pr5);
fm.addCorrespondence(pl6, pr6);
fm.addCorrespondence(pl7, pr7);
fm.addCorrespondence(pl8, pr8);
fm.addCorrespondence(pl9, pr9);
fm.addCorrespondence(plA, prA);
fm.addCorrespondence(plB, prB);
fm.estimate();
}
bool MyFrameListener::deleteBoard()
{
for (int i=0; i<_XMAX; i++)
{
for (int j=0; j<_YMAX; j++)
{
myBoard[i][j]=0;
}
}
for (int i=0; i<_XMAX; i++)
{
for (int j=0; j<_YMAX; j++)
{
myBoardPlayer[i][j]=0;
}
}
_maxFires=0;
_sceneManager->getRootSceneNode()->removeAndDestroyAllChildren();
_sceneManager->clearScene();
// Añadir el plano a la escena
// Creacion del plano
Ogre::Plane pl1(Ogre::Vector3::UNIT_Y,-5);
Ogre::MeshManager::getSingleton().createPlane("pl1",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
pl1,200,200,1,1,true,1,20,20,Ogre::Vector3::UNIT_Z);
// Añadir el plano a la escena
Ogre::SceneNode* nodeG = _sceneManager->createSceneNode("nodeG");
Ogre::Entity* grEnt = _sceneManager->createEntity("pEnt", "pl1");
grEnt->setMaterialName("Ground");
nodeG->attachObject(grEnt);
// Sombras
_sceneManager->setShadowTechnique(Ogre::SHADOWTYPE_STENCIL_ADDITIVE);
Ogre::Light* light = _sceneManager->createLight("light1");
light->setType(Ogre::Light::LT_DIRECTIONAL);
light->setDirection(Ogre::Vector3(1,-1,0));
nodeG->attachObject(light);
_sceneManager->getRootSceneNode()->addChild(nodeG);
return true;
}
int main()
{
CMyList lst;
CPlorg pl1("Plorg1", 100);
CPlorg pl2("Plorg2", 200);
CPlorg pl3("Plorg3", 300);
lst + &pl1;
lst + &pl2;
lst + &pl3;
lst.GetItem(2)->ShowData();
lst.GetItem(2)->ChangeCI(500);
lst.GetItem(2)->ShowData();
lst.operator-();
lst.GetItem(2);
std::cin.get();
return 0;
}
Garden() {
fileLeft = getDataFile("stereo1.jpg"); // left image
fileRight = getDataFile("stereo2.jpg"); // right image
imgLeft = ImageFactory::readJPEG(fileLeft);
imgRight = ImageFactory::readJPEG(fileRight);
MatchingSAD sad(imgLeft, imgRight, 15);
Matching matcher;
// image1 // image2 (left of image1) // refine the approximate matching positions
Point2i pl1(85,53); Point2i pr1(29,57); pr1 = matcher.refine(sad, pl1, pr1);
Point2i pl2(264,34); Point2i pr2(209,36); pr2 = matcher.refine(sad, pl2, pr2);
Point2i pl3(362,32); Point2i pr3(306,32); pr3 = matcher.refine(sad, pl3, pr3);
Point2i pl4(213,155); Point2i pr4(155,159); pr4 = matcher.refine(sad, pl4, pr4);
Point2i pl5(96,209); Point2i pr5(36,210); pr5 = matcher.refine(sad, pl5, pr5);
Point2i pl6(330,212); Point2i pr6(269,211); pr6 = matcher.refine(sad, pl6, pr6);
Point2i pl7(276,241); Point2i pr7(216,242); pr7 = matcher.refine(sad, pl7, pr7);
Point2i pl8(385,332); Point2i pr8(321,328); pr8 = matcher.refine(sad, pl8, pr8);
Point2i pl9(180,389); Point2i pr9(114,388); pr9 = matcher.refine(sad, pl9, pr9);
Point2i pl10(136,500); Point2i pr10(67,500); pr10 = matcher.refine(sad, pl10, pr10);
fm.addCorrespondence(pl1, pr1);
fm.addCorrespondence(pl2, pr2);
fm.addCorrespondence(pl3, pr3);
fm.addCorrespondence(pl4, pr4);
fm.addCorrespondence(pl5, pr5);
fm.addCorrespondence(pl6, pr6);
fm.addCorrespondence(pl7, pr7);
fm.addCorrespondence(pl8, pr8);
// fm.addCorrespondence(pl9, pr9);
// fm.addCorrespondence(pl10, pr10);
fm.estimate();
}
template<typename HyperplaneType> void hyperplane(const HyperplaneType& _plane)
{
/* this test covers the following files:
Hyperplane.h
*/
const int dim = _plane.dim();
typedef typename HyperplaneType::Scalar Scalar;
typedef typename NumTraits<Scalar>::Real RealScalar;
typedef Matrix<Scalar, HyperplaneType::AmbientDimAtCompileTime, 1> VectorType;
typedef Matrix<Scalar, HyperplaneType::AmbientDimAtCompileTime,
HyperplaneType::AmbientDimAtCompileTime> MatrixType;
VectorType p0 = VectorType::Random(dim);
VectorType p1 = VectorType::Random(dim);
VectorType n0 = VectorType::Random(dim).normalized();
VectorType n1 = VectorType::Random(dim).normalized();
HyperplaneType pl0(n0, p0);
HyperplaneType pl1(n1, p1);
HyperplaneType pl2 = pl1;
Scalar s0 = ei_random<Scalar>();
Scalar s1 = ei_random<Scalar>();
VERIFY_IS_APPROX( n1.dot(n1), Scalar(1) );
VERIFY_IS_MUCH_SMALLER_THAN( pl0.absDistance(p0), Scalar(1) );
VERIFY_IS_APPROX( pl1.signedDistance(p1 + n1 * s0), s0 );
VERIFY_IS_MUCH_SMALLER_THAN( pl1.signedDistance(pl1.projection(p0)), Scalar(1) );
VERIFY_IS_MUCH_SMALLER_THAN( pl1.absDistance(p1 + pl1.normal().unitOrthogonal() * s1), Scalar(1) );
// transform
if (!NumTraits<Scalar>::IsComplex)
{
MatrixType rot = MatrixType::Random(dim,dim).qr().matrixQ();
Scaling<Scalar,HyperplaneType::AmbientDimAtCompileTime> scaling(VectorType::Random());
Translation<Scalar,HyperplaneType::AmbientDimAtCompileTime> translation(VectorType::Random());
pl2 = pl1;
VERIFY_IS_MUCH_SMALLER_THAN( pl2.transform(rot).absDistance(rot * p1), Scalar(1) );
pl2 = pl1;
VERIFY_IS_MUCH_SMALLER_THAN( pl2.transform(rot,Isometry).absDistance(rot * p1), Scalar(1) );
pl2 = pl1;
VERIFY_IS_MUCH_SMALLER_THAN( pl2.transform(rot*scaling).absDistance((rot*scaling) * p1), Scalar(1) );
pl2 = pl1;
VERIFY_IS_MUCH_SMALLER_THAN( pl2.transform(rot*scaling*translation)
.absDistance((rot*scaling*translation) * p1), Scalar(1) );
pl2 = pl1;
VERIFY_IS_MUCH_SMALLER_THAN( pl2.transform(rot*translation,Isometry)
.absDistance((rot*translation) * p1), Scalar(1) );
}
// casting
const int Dim = HyperplaneType::AmbientDimAtCompileTime;
typedef typename GetDifferentType<Scalar>::type OtherScalar;
Hyperplane<OtherScalar,Dim> hp1f = pl1.template cast<OtherScalar>();
VERIFY_IS_APPROX(hp1f.template cast<Scalar>(),pl1);
Hyperplane<Scalar,Dim> hp1d = pl1.template cast<Scalar>();
VERIFY_IS_APPROX(hp1d.template cast<Scalar>(),pl1);
}
//
// Test of the Instance creation and instance filtering
//
void test04()
{
if (verbose)
{
cout << "Test04 - Create instance from Class. " << endl;
}
const CIMNamespaceName NAMESPACE = CIMNamespaceName("/zzz");
// Create and populate a declaration context:
SimpleDeclContext* context = new SimpleDeclContext;
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName("counter"), false,
CIMScope::PROPERTY));
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName("classcounter"), false,
CIMScope::CLASS));
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName("min"), String(),
CIMScope::PROPERTY));
context->addQualifierDecl(
NAMESPACE, CIMQualifierDecl(CIMName("max"), String(),
CIMScope::PROPERTY));
context->addQualifierDecl(NAMESPACE,
CIMQualifierDecl(CIMName("Description"), String(),
CIMScope::PROPERTY));
CIMClass class1(CIMName("MyClass"));
class1
.addProperty(CIMProperty(CIMName("count"), Uint32(55))
.addQualifier(CIMQualifier(CIMName("counter"), true))
.addQualifier(CIMQualifier(CIMName("min"), String("0")))
.addQualifier(CIMQualifier(CIMName("max"), String("1"))))
.addProperty(CIMProperty(CIMName("message"), String("Hello"))
.addQualifier(CIMQualifier(CIMName("description"),
String("My Message"))))
.addProperty(CIMProperty(CIMName("ratio"), Real32(1.5)));
Resolver::resolveClass(class1, context, NAMESPACE);
context->addClass(NAMESPACE, class1);
if (verbose)
{
XmlWriter::printClassElement(class1);
}
//
// Create instance with qualifiers, classorigin, and Null propertyList
//
{
CIMInstance newInstance;
newInstance = class1.buildInstance(true, true, CIMPropertyList());
if (verbose)
{
XmlWriter::printInstanceElement(newInstance);
}
assert(newInstance.getPropertyCount() == class1.getPropertyCount());
assert(newInstance.getQualifierCount() == class1.getQualifierCount());
assert(newInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(newInstance.findProperty("message") != PEG_NOT_FOUND);
}
//
// Test with include qualifiers false. Should be no qualifiers in result
//
{
CIMInstance newInstance =
class1.buildInstance(false, true, CIMPropertyList());
assert(newInstance.getQualifierCount() == 0);
assert(newInstance.getPropertyCount() == class1.getPropertyCount());
assert(newInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(newInstance.findProperty("message") != PEG_NOT_FOUND);
}
//
// Test with empty property list. Should have no properties.
//
{
Array<CIMName> pl1Array;
CIMPropertyList pl1(pl1Array);
CIMInstance newInstance = class1.buildInstance(false, true, pl1);
assert(newInstance.getQualifierCount() == 0);
assert(newInstance.getPropertyCount() == 0);
}
//
// Test with a property that exists in property list.
//
{
Array<CIMName> pl1Array;
pl1Array.append("ratio");
CIMPropertyList pl1(pl1Array);
CIMInstance newInstance = class1.buildInstance(false, true, pl1);
if (verbose)
{
cout << "Test with one property in new instance" << endl;
XmlWriter::printInstanceElement(newInstance);
}
assert(newInstance.getPropertyCount() == 1);
assert(newInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(newInstance.findProperty("message") == PEG_NOT_FOUND);
assert(newInstance.getQualifierCount() == 0);
}
//
// Test with a property that does/does not exist in property list
//
{
Array<CIMName> pl1Array;
CIMPropertyList pl1(pl1Array);
pl1.clear();
pl1Array.append("blob");
pl1Array.append("ratio");
pl1.set(pl1Array);
CIMInstance newInstance = class1.buildInstance(false, true, pl1);
assert(newInstance.getPropertyCount() == 1);
assert(newInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(newInstance.findProperty("blob") == PEG_NOT_FOUND);
assert(newInstance.findProperty("message") == PEG_NOT_FOUND);
assert(newInstance.getQualifierCount() == 0);
}
///////////////////////////////////////////////////////////////////////
//
// Instance Filtering function tests
//
///////////////////////////////////////////////////////////////////////
// build instance as starting point for tests.
CIMInstance tstInstance =
class1.buildInstance(true, true, CIMPropertyList());
//
// Test complete copy, no change
//
{
if (verbose)
{
cout << "Test1" << endl;
}
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, CIMPropertyList());
assert(tstInstance.identical(filterInstance));
assert(filterInstance.getPropertyCount() == 3);
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to one property, ratio
//
{
if (verbose)
{
cout << "Test2" << endl;
}
Array<CIMName> pl1Array;
pl1Array.append("ratio");
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, pl1);
if (verbose)
{
XmlWriter::printInstanceElement(filterInstance);
}
assert(filterInstance.getPropertyCount() == 1);
assert(filterInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(_propertyIdentical("ratio", filterInstance, tstInstance));
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to one property, message
//
{
if (verbose)
{
cout << "Test3" << endl;
}
Array<CIMName> pl1Array;
pl1Array.append("message");
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, pl1);
if (verbose)
{
XmlWriter::printInstanceElement(filterInstance);
}
assert(filterInstance.getPropertyCount() == 1);
assert(filterInstance.findProperty("message") != PEG_NOT_FOUND);
assert(_propertyIdentical("message", filterInstance, tstInstance));
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to one property, count
//
{
if (verbose)
{
cout << "Test4" << endl;
}
Array<CIMName> pl1Array;
pl1Array.append("count");
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, pl1);
if (verbose)
{
XmlWriter::printInstanceElement(filterInstance);
}
assert(filterInstance.getPropertyCount() == 1);
assert(filterInstance.findProperty("count") != PEG_NOT_FOUND);
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to no properties
//
{
if (verbose)
{
cout << "Test5a" << endl;
}
Array<CIMName> pl1Array;
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, pl1);
assert(filterInstance.getPropertyCount() == 0);
assert(filterInstance.findProperty("ratio") == PEG_NOT_FOUND);
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to two properties
//
{
if (verbose)
{
cout << "Test5b" << endl;
}
Array<CIMName> pl1Array;
pl1Array.append("count");
pl1Array.append("message");
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(true, true, pl1);
assert(filterInstance.getPropertyCount() == 2);
assert(filterInstance.findProperty("ratio") == PEG_NOT_FOUND);
assert(filterInstance.findProperty("message") != PEG_NOT_FOUND);
assert(_propertyIdentical("message", filterInstance, tstInstance));
assert(filterInstance.findProperty("count") != PEG_NOT_FOUND);
assert(_propertyIdentical("count", filterInstance, tstInstance));
assert(filterInstance.getQualifierCount() ==
tstInstance.getQualifierCount());
}
//
// Filter to no qualifiers and all properties.
//
{
if (verbose)
{
cout << "Test6" << endl;
}
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(false, true, CIMPropertyList());
assert(filterInstance.getPropertyCount() == 3);
assert(filterInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(filterInstance.getQualifierCount() == 0);
for (Uint32 i = 0; i < filterInstance.getPropertyCount() ; i++)
{
CIMConstProperty p = filterInstance.getProperty(i);
assert(p.getQualifierCount() == 0);
}
}
//
// Filter to no qualifiers and no properties.
//
{
if (verbose)
{
cout << "Test6a" << endl;
}
Array<CIMName> pl1Array;
CIMPropertyList pl1(pl1Array);
CIMInstance filterInstance = tstInstance.clone();
filterInstance.filter(false, true, pl1);
assert(filterInstance.getPropertyCount() == 0);
assert(filterInstance.findProperty("ratio") == PEG_NOT_FOUND);
assert(filterInstance.getQualifierCount() == 0);
}
//
// Test Class Origin Filter
//
{
if (verbose)
{
cout << "Test7 Class Origin" << endl;
}
// Create a subclass to do classOrigin testing
CIMClass mySubClass(CIMName("subclass"));
mySubClass.setSuperClassName(CIMName("MyClass"));
Resolver::resolveClass(mySubClass, context, NAMESPACE);
context->addClass(NAMESPACE, mySubClass);
// build instance
CIMInstance filterInstance =
mySubClass.buildInstance(true, true, CIMPropertyList());
filterInstance.filter(false, true, CIMPropertyList());
assert(filterInstance.getPropertyCount() == 3);
assert(filterInstance.findProperty("ratio") != PEG_NOT_FOUND);
assert(filterInstance.getQualifierCount() == 0);
for (Uint32 i = 0 ; i < filterInstance.getPropertyCount() ; i++)
{
CIMProperty p = filterInstance.getProperty(i);
assert(!(p.getClassOrigin() == CIMName()));
}
filterInstance.filter(false, false, CIMPropertyList());
for (Uint32 i = 0 ; i < filterInstance.getPropertyCount() ; i++)
{
CIMProperty p = filterInstance.getProperty(i);
assert(p.getClassOrigin() == CIMName());
}
CIMInstance filterInstance2 =
mySubClass.buildInstance(true, false, CIMPropertyList());
for (Uint32 i = 0 ; i < filterInstance2.getPropertyCount() ; i++)
{
CIMProperty p = filterInstance2.getProperty(i);
assert(p.getClassOrigin() == CIMName());
}
}
delete context;
}
void createScene() {
Ogre::SceneNode* nroca = mSceneMgr->createSceneNode("nroca");
Ogre::Entity *roca = mSceneMgr->createEntity("roca", "cube.mesh");
nroca->attachObject(roca);
mSceneMgr->getRootSceneNode()->addChild(nroca);
Ogre::SceneNode* ntronco = mSceneMgr->createSceneNode("ntronco");
Ogre::Entity *tronco = mSceneMgr->createEntity("tronco", "cube.mesh");
ntronco->attachObject(tronco);
mSceneMgr->getRootSceneNode()->addChild(ntronco);
Ogre::SceneNode* ncabeza = mSceneMgr->createSceneNode("ncabeza");
Ogre::Entity *cabeza = mSceneMgr->createEntity("cabeza", "cube.mesh");
ncabeza->attachObject(cabeza);
ntronco->addChild(ncabeza);
Ogre::SceneNode* nbase = mSceneMgr->createSceneNode("nbase");
Ogre::Entity *base = mSceneMgr->createEntity("base", "cube.mesh");
nbase->attachObject(base);
ncabeza->addChild(nbase);
Ogre::SceneNode* nsombrero = mSceneMgr->createSceneNode("nsombrero");
Ogre::Entity *sombrero = mSceneMgr->createEntity("sombrero", "cube.mesh");
nsombrero->attachObject(sombrero);
nbase->addChild(nsombrero);
Ogre::SceneNode* nbrazoizq = mSceneMgr->createSceneNode("nbrazoizq");
Ogre::Entity *brazoizq = mSceneMgr->createEntity("brazoizq", "cube.mesh");
nbrazoizq->attachObject(brazoizq);
ntronco->addChild(nbrazoizq);
Ogre::SceneNode* nbrazoder = mSceneMgr->createSceneNode("nbrazoder");
Ogre::Entity *brazoder = mSceneMgr->createEntity("brazoder", "cube.mesh");
nbrazoder->attachObject(brazoder);
ntronco->addChild(nbrazoder);
Ogre::SceneNode* npiernaizq = mSceneMgr->createSceneNode("npiernaizq");
Ogre::Entity *piernaizq = mSceneMgr->createEntity("piernaizq", "cube.mesh");
npiernaizq->attachObject(piernaizq);
ntronco->addChild(npiernaizq);
Ogre::SceneNode* npiernader = mSceneMgr->createSceneNode("npiernader");
Ogre::Entity *piernader = mSceneMgr->createEntity("piernader", "cube.mesh");
npiernader->attachObject(piernader);
ntronco->addChild(npiernader);
Ogre::SceneNode* npieder = mSceneMgr->createSceneNode("npieder");
Ogre::Entity *pieder = mSceneMgr->createEntity("pieder", "cube.mesh");
npieder->attachObject(pieder);
npiernader->addChild(npieder);
nroca->setPosition(0,7,0);
nroca->setScale(7,7,7);
nroca->pitch(Degree(30));
nroca->roll(Degree(-45));
ntronco->setPosition(-20,4,0);
ntronco->setScale(1,3,1);
ntronco->roll(Degree(17));
ncabeza->setPosition(0.25,1.35,0);
ncabeza->setScale(1,0.33,1);
ncabeza->roll(Degree(-10));
nbase->setPosition(0.25,2,0);
nbase->setScale(1,0.15,1);
nbase->roll(Degree(-30));
nsombrero->setPosition(0,2.5,0);
nsombrero->setScale(0.5,3.5,0.5);
nbrazoder->setScale(0.5,1,0.5);
nbrazoder->setPosition(-2,0.65,-2.25);
nbrazoder->roll(Degree(90));
nbrazoder->pitch(Degree(-30));
nbrazoizq->setScale(0.5,1,0.5);
nbrazoizq->setPosition(-2,0.65,2.25);
nbrazoizq->roll(Degree(100));
nbrazoizq->pitch(Degree(30));
npiernaizq->setPosition(-1.75,-1.75,-0.25);
npiernaizq->setScale(0.5,1,0.5);
npiernaizq->roll(Degree(-45));
npiernader->setPosition(1,-1.35,0.5);
npiernader->setScale(0.5,0.5,0.5);
npiernader->roll(Degree(35));
npieder->setPosition(2.25,-1.25,1.75);
npieder->roll(Degree(90));
Ogre::Plane pl1(Ogre::Vector3::UNIT_Y, -5);
Ogre::MeshManager::getSingleton().createPlane("pl1",Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,pl1,200,200,1,1,true,1,20,20,Ogre::Vector3::UNIT_Z);
Ogre::SceneNode* nground = mSceneMgr->createSceneNode("ground");
Ogre::Entity *ground = mSceneMgr->createEntity("pEnt","pl1");
ground->setMaterialName("Ground");
nground->attachObject(ground);
mSceneMgr->getRootSceneNode()->addChild(nground);
mSceneMgr->setAmbientLight(Ogre::ColourValue(0.5, 0.5, 0.5));
}
