//////////////////////////////////////////////////////////////////////////
//! build a sphere
//////////////////////////////////////////////////////////////////////////
void buildSphere(void)
{
Real32 Radius(frand()*1.5+0.2);
Matrix m;
//create OpenSG mesh
GeometryPtr sphere;
NodePtr sphereNode = makeSphere(2, Radius);
sphere = GeometryPtr::dcast(sphereNode->getCore());
SimpleMaterialPtr sphere_mat = SimpleMaterial::create();
beginEditCP(sphere_mat);
sphere_mat->setAmbient(Color3f(0.0,0.0,0.0));
sphere_mat->setDiffuse(Color3f(0.0,0.0,1.0));
endEditCP(sphere_mat);
beginEditCP(sphere, Geometry::MaterialFieldMask);
sphere->setMaterial(sphere_mat);
endEditCP(sphere);
TransformPtr sphereTrans;
NodePtr sphereTransNode = makeCoredNode<Transform>(&sphereTrans);
m.setIdentity();
Real32 randX = frand()*10.0-5.0;
Real32 randY = frand()*10.0-5.0;
m.setTranslate(randX, randY, 10.0);
beginEditCP(sphereTrans, Transform::MatrixFieldMask);
sphereTrans->setMatrix(m);
endEditCP(sphereTrans);
//create ODE data
PhysicsBodyPtr sphereBody = PhysicsBody::create(physicsWorld);
beginEditCP(sphereBody, PhysicsBody::PositionFieldMask | PhysicsBody::AngularDampingFieldMask);
sphereBody->setPosition(Vec3f(randX, randY, 10.0));
sphereBody->setAngularDamping(0.0001);
endEditCP(sphereBody, PhysicsBody::PositionFieldMask | PhysicsBody::AngularDampingFieldMask);
sphereBody->setSphereMass(0.4,Radius);
PhysicsSphereGeomPtr sphereGeom = PhysicsSphereGeom::create();
beginEditCP(sphereGeom, PhysicsSphereGeom::BodyFieldMask | PhysicsSphereGeom::SpaceFieldMask | PhysicsSphereGeom::RadiusFieldMask | PhysicsSphereGeom::CategoryBitsFieldMask);
sphereGeom->setBody(sphereBody);
sphereGeom->setSpace(physicsSpace);
sphereGeom->setRadius(Radius);
sphereGeom->setCategoryBits(SphereCategory);
endEditCP(sphereGeom, PhysicsSphereGeom::BodyFieldMask | PhysicsSphereGeom::SpaceFieldMask | PhysicsSphereGeom::RadiusFieldMask | PhysicsSphereGeom::CategoryBitsFieldMask);
//add attachments
beginEditCP(sphereNode, Node::AttachmentsFieldMask);
sphereNode->addAttachment(sphereGeom);
endEditCP(sphereNode);
beginEditCP(sphereTransNode, Node::AttachmentsFieldMask | Node::ChildrenFieldMask);
sphereTransNode->addAttachment(sphereBody);
sphereTransNode->addChild(sphereNode);
endEditCP(sphereTransNode);
//add to SceneGraph
beginEditCP(spaceGroupNode, Node::ChildrenFieldMask);
spaceGroupNode->addChild(sphereTransNode);
endEditCP(spaceGroupNode);
}
void object::test<10>()
{
geos::geom::Coordinate coord(x_, y_, z_);
CoordArrayPtr sequence = new geos::geom::CoordinateArraySequence();
ensure( "sequence is null pointer.", sequence != 0 );
sequence->add(coord);
PointPtr pt = factory_.createPoint(sequence);
ensure( "createPoint() returned null pointer.", pt != 0 );
ensure( "createPoint() returned empty point.", !pt->isEmpty() );
ensure( pt->isSimple() );
ensure( pt->isValid() );
ensure( pt->getCoordinate() != 0 );
CoordinateCPtr pcoord = pt->getCoordinate();
ensure( pcoord != 0 );
ensure_equals( pcoord->x, x_ );
ensure_equals( pcoord->y, y_ );
ensure_equals( pcoord->z, z_ );
GeometryPtr geo = 0;
geo = pt->getEnvelope();
ensure( geo != 0 );
ensure( !geo->isEmpty() );
factory_.destroyGeometry(geo);
geo = pt->getCentroid();
ensure( geo != 0 );
ensure( !geo->isEmpty() );
factory_.destroyGeometry(geo);
geo = pt->getBoundary();
ensure( geo != 0 );
ensure( geo->isEmpty() );
factory_.destroyGeometry(geo);
geo = pt->convexHull();
ensure( geo != 0 );
ensure( !geo->isEmpty() );
factory_.destroyGeometry(geo);
ensure_equals( pt->getGeometryTypeId(), geos::geom::GEOS_POINT );
ensure_equals( pt->getDimension(), geos::geom::Dimension::P );
ensure_equals( pt->getBoundaryDimension(), geos::geom::Dimension::False );
ensure_equals( pt->getNumPoints(), 1u );
ensure_equals( pt->getLength(), 0.0 );
ensure_equals( pt->getArea(), 0.0 );
// FREE MEMORY
factory_.destroyGeometry(pt);
}
void object::test<25>()
{
GeometryPtr geo = reader_.read("LINESTRING (0 0, 10 10, 20 0)");
ensure( geo != 0 );
const std::string type("LineString");
ensure_equals( geo->getGeometryType(), type );
// FREE MEMORY
factory_.destroyGeometry(geo);
}
void object::test<4>()
{
using geos::geom::Coordinate;
// Non-empty sequence of coordiantes
const size_t size = 3;
CoordArrayPtr pseq = new geos::geom::CoordinateArraySequence();
ensure( "sequence is null pointer.", pseq != 0 );
pseq->add(Coordinate(0, 0, 0));
pseq->add(Coordinate(5, 5, 5));
pseq->add(Coordinate(10, 10, 10));
ensure_equals( pseq->size(), size );
// Create examplar of linstring instance
LineStringAutoPtr examplar(factory_.createLineString(pseq));
// Create copy
LineStringAutoPtr copy(dynamic_cast<geos::geom::LineString*>(examplar->clone()));
ensure( 0 != copy.get() );
ensure( !copy->isEmpty() );
ensure( copy->isSimple() );
ensure( copy->isValid() );
ensure( !copy->isClosed() );
ensure( !copy->isRing() );
GeometryPtr geo = 0;
geo = copy->getEnvelope();
ensure( geo != 0 );
ensure( !geo->isEmpty() );
factory_.destroyGeometry(geo);
geo = copy->getBoundary();
ensure( geo != 0 );
ensure( !geo->isEmpty() );
factory_.destroyGeometry(geo);
geo = copy->convexHull();
ensure( geo != 0 );
ensure( !geo->isEmpty() );
factory_.destroyGeometry(geo);
ensure_equals( copy->getGeometryTypeId(), geos::geom::GEOS_LINESTRING );
ensure_equals( copy->getDimension(), geos::geom::Dimension::L );
ensure_equals( copy->getBoundaryDimension(), geos::geom::Dimension::P );
ensure_equals( copy->getNumPoints(), size );
ensure_equals( copy->getArea(), 0.0 );
ensure( copy->getLength() != 0.0 );
}
void object::test<22>()
{
const size_t size = 4;
GeometryPtr geo = reader_.read("LINESTRING (0 0, 5 5, 10 5, 10 10)");
ensure( geo != 0 );
ensure_equals( geo->getNumPoints(), size );
// FREE TESTED LINESTRING
factory_.destroyGeometry(geo);
}
void object::test<17>()
{
ensure( poly_ != nullptr );
GeometryPtr envelope = poly_->getEnvelope();
ensure( envelope != nullptr );
ensure( !envelope->isEmpty() );
ensure_equals( envelope->getDimension(), geos::geom::Dimension::A );
// FREE MEMORY
factory_->destroyGeometry(envelope);
}
void object::test<18>()
{
ensure( poly_ != nullptr );
GeometryPtr boundary = poly_->getBoundary();
ensure( boundary != nullptr );
// OGC 05-126, Version: 1.1.0, Chapter 6.1.10 Surface
ensure( "[OGC] The boundary of Polygin is the set of closed Curves.", !boundary->isEmpty() );
// FREE MEMORY
factory_->destroyGeometry(boundary);
}
void GlUtils::renderGeometry(
const GeometryPtr & geometry,
gl::ProgramPtr program) {
program->use();
Stacks::lights().apply(program);
Stacks::projection().apply(program);
Stacks::modelview().apply(program);
geometry->bindVertexArray();
geometry->draw();
VertexArray::unbind();
Program::clear();
}
void object::test<19>()
{
ensure( poly_ != nullptr );
GeometryPtr hull = poly_->convexHull();
ensure( hull != nullptr );
ensure( !hull->isEmpty() );
ensure_equals( hull->getGeometryTypeId(), geos::geom::GEOS_POLYGON );
ensure_equals( hull->getDimension(), geos::geom::Dimension::A );
// FREE MEMORY
factory_->destroyGeometry(hull);
}
void object::test<2>()
{
using geos::geom::Coordinate;
// Non-empty sequence of coordiantes
const size_t size3 = 3;
CoordArrayPtr pseq = new geos::geom::CoordinateArraySequence();
ensure( "sequence is null pointer.", pseq != 0 );
pseq->add(Coordinate(0, 0, 0));
pseq->add(Coordinate(5, 5, 5));
pseq->add(Coordinate(10, 10, 10));
ensure_equals( pseq->size(), size3 );
// Create non-empty linstring instance
LineStringAutoPtr ls(factory_.createLineString(pseq));
ensure( !ls->isEmpty() );
ensure( ls->isSimple() );
ensure( ls->isValid() );
ensure( !ls->isClosed() );
ensure( !ls->isRing() );
GeometryPtr geo = 0;
geo = ls->getEnvelope();
ensure( geo != 0 );
ensure( !geo->isEmpty() );
factory_.destroyGeometry(geo);
geo = ls->getBoundary();
ensure( geo != 0 );
ensure( !geo->isEmpty() );
factory_.destroyGeometry(geo);
geo = ls->convexHull();
ensure( geo != 0 );
ensure( !geo->isEmpty() );
factory_.destroyGeometry(geo);
ensure_equals( ls->getGeometryTypeId(), geos::geom::GEOS_LINESTRING );
ensure_equals( ls->getDimension(), geos::geom::Dimension::L );
ensure_equals( ls->getBoundaryDimension(), geos::geom::Dimension::P );
ensure_equals( ls->getCoordinateDimension(), 3 );
ensure_equals( ls->getNumPoints(), size3 );
ensure_equals( ls->getArea(), 0.0 );
ensure( ls->getLength() != 0.0 );
}
void GlUtils::draw3dVector(glm::vec3 vec, const glm::vec3 & col) {
Mesh m;
m.color = Colors::gray;
m.addVertex(glm::vec3());
m.addVertex(glm::vec3(vec.x, 0, vec.z));
m.addVertex(glm::vec3(vec.x, 0, vec.z));
m.addVertex(vec);
m.fillColors(true);
m.color = col;
m.addVertex(vec);
m.addVertex(glm::vec3());
m.fillColors();
static GeometryPtr g = m.getGeometry(GL_LINES);
g->updateVertices(m.buildVertices());
ProgramPtr program = getProgram(
Resource::SHADERS_COLORED_VS,
Resource::SHADERS_COLORED_FS);
program->use();
renderGeometry(g, program);
gl::Program::clear();
// lineWidth(1.0f);
// float len = glm::length(vec);
// if (len > 1.0f) {
// vec /= len;
// }
// gl::Program::clear();
//
// glLineWidth(2.0f + len);
// glBegin(GL_LINES);
// gl::color(col);
// gl::vertex();
// gl::vertex();
// glEnd();
//
// glLineWidth(1.0f);
// glBegin(GL_LINE_STRIP);
// gl::color(Colors::gray);
// gl::vertex(glm::vec3());
// gl::vertex(glm::vec3(vec.x, 0, vec.z));
// gl::vertex(vec);
// glEnd();
}
void object::test<23>()
{
const double tolerance = 0.0001;
const double expected = 2 * 14.142135600000000;
GeometryPtr geo = reader_.read("LINESTRING (0 0, 10 10, 20 0)");
ensure( geo != 0 );
ensure( geo->getLength() != 0.0 );
const double diff = std::fabs(geo->getLength() - expected);
ensure( diff <= tolerance );
// FREE TESTED LINESTRING
factory_.destroyGeometry(geo);
}
int kml2tessellate_rec (
GeometryPtr poKmlGeometry,
int *pnTessellate )
{
LineStringPtr poKmlLineString;
PolygonPtr poKmlPolygon;
MultiGeometryPtr poKmlMultiGeometry;
size_t nGeom;
size_t i;
switch ( poKmlGeometry->Type ( ) ) {
case kmldom::Type_Point:
break;
case kmldom::Type_LineString:
poKmlLineString = AsLineString ( poKmlGeometry );
if ( poKmlLineString->has_tessellate ( ) ) {
*pnTessellate = poKmlLineString->get_tessellate ( );
return TRUE;
}
break;
case kmldom::Type_LinearRing:
break;
case kmldom::Type_Polygon:
poKmlPolygon = AsPolygon ( poKmlGeometry );
if ( poKmlPolygon->has_tessellate ( ) ) {
*pnTessellate = poKmlPolygon->get_tessellate ( );
return TRUE;
}
break;
case kmldom::Type_MultiGeometry:
poKmlMultiGeometry = AsMultiGeometry ( poKmlGeometry );
nGeom = poKmlMultiGeometry->get_geometry_array_size ( );
for ( i = 0; i < nGeom; i++ ) {
if ( kml2tessellate_rec ( poKmlMultiGeometry->
get_geometry_array_at ( i ),
pnTessellate ) )
return TRUE;
}
break;
default:
break;
}
return FALSE;
}
// redraw the window
void display( void )
{
// create the matrix
Matrix m;
Real32 t = glutGet(GLUT_ELAPSED_TIME );
m.setTransform(Quaternion( Vec3f(0,1,0),
t / 1000.f));
// set the transform's matrix
beginEditCP(trans, Transform::MatrixFieldMask);
{
trans->setMatrix(m);
}
endEditCP (trans, Transform::MatrixFieldMask);
/*
Manipulate the geometry.
The OpenSG geometry structure is pretty flexible.
The disadvantage of all this flexibility is that it can be hard to
write generic tools, as pretty much all the used types can be one of a
number of variants.
To simplify that, every kind of GeoProperty has a generic type, e.g.
the generic type for positions is Pnt3f, for colors it's Color3f.
No matter the internal data representation looks like, all
GeoProperties have the generic interface. As does the abstract parent
class of every kind of property. Thus it's possible to access the data
of an arbitrary geometry using the generic interface.
*/
// note that this is the abstract parent class, it doesn't have a specific
// type
GeoPositionsPtr pos = geo->getPositions();
beginEditCP(pos);
for(UInt32 i = 0; i < pos->getSize(); i++)
{
Pnt3f p;
pos->getValue(p, i);
p[0] += osgsin(t / 300) * p[1] / 100;
p[1] += osgsin(t / 300) * p[2] / 100;
p[2] += osgsin(t / 300) * p[0] / 100;
pos->setValue(p, i);
}
endEditCP (pos);
// right now the geometry doesn't notice changes to the properties, it has
// to be notified explicitly
beginEditCP(geo, Geometry::PositionsFieldMask);
endEditCP (geo, Geometry::PositionsFieldMask);
mgr->redraw();
}
void object::test<5>()
{
using geos::geom::PrecisionModel;
PrecisionModel pm(PrecisionModel::FIXED);
geos::geom::GeometryFactory gf(&pm, srid_);
ensure_equals( gf.getSRID(), srid_ );
ensure_equals( gf.getPrecisionModel()->getType(), PrecisionModel::FIXED );
GeometryPtr geo = gf.createEmptyGeometry();
ensure( "createEmptyGeometry() returned null pointer.", geo != 0 );
ensure_equals( geo->getSRID() , gf.getSRID() );
ensure_equals( geo->getPrecisionModel()->getType(), PrecisionModel::FIXED );
// FREE MEMORY
gf.destroyGeometry(geo);
}
void object::test<16>()
{
GeometryPtr geo = reader_.read("LINESTRING (0 0, 5 5, 10 5, 10 10)");
ensure( geo != 0 );
LineStringPtr line = dynamic_cast<LineStringPtr>(geo);
ensure(line != 0);
GeometryPtr envelope = line->getEnvelope();
ensure( envelope != 0 );
ensure( !envelope->isEmpty() );
ensure_equals( envelope->getDimension(), geos::geom::Dimension::A );
factory_.destroyGeometry(envelope);
// FREE TESTED LINESTRING
factory_.destroyGeometry(line);
}
typename Spatialize<BasicTraits>::ResultT
Spatialize<BasicTraits>::LeafEnter (AdapterType* node)
{
// create new node with transformed positions and normals
NodePtr newNode = Node::create();
GeometryPtr oldCore = GeometryPtr::dcast(node->getOriginal()->getCore());
GeometryPtr newCore = oldCore->clone();
beginEditCP(newNode);
newNode->setCore(newCore);
endEditCP(newNode);
beginEditCP(newCore);
newCore->setPositions(node->getPositions());
newCore->setNormals (node->getNormals());
endEditCP(newCore);
m_rootLevel->addChild(newNode);
return SingleTraverserBase<BasicTraits>::CONTINUE;
}
void object::test<17>()
{
GeometryPtr geo = reader_.read("LINESTRING (0 0, 5 5, 10 5, 10 10)");
ensure( geo != 0 );
LineStringPtr line = dynamic_cast<LineStringPtr>(geo);
ensure(line != 0);
GeometryPtr boundary = line->getBoundary();
ensure( boundary != 0 );
ensure( !boundary->isEmpty() );
ensure_equals( boundary->getGeometryTypeId(), geos::geom::GEOS_MULTIPOINT );
ensure_equals( boundary->getDimension(), geos::geom::Dimension::P );
factory_.destroyGeometry(boundary);
// FREE TESTED LINESTRING
factory_.destroyGeometry(line);
}
void object::test<18>()
{
GeometryPtr geo = reader_.read("LINESTRING (0 0, 5 5, 10 5, 10 10)");
ensure( geo != 0 );
LineStringPtr line = dynamic_cast<LineStringPtr>(geo);
ensure(line != 0);
GeometryPtr hull = line->convexHull();
ensure( hull != 0 );
ensure( !hull->isEmpty() );
ensure_equals( hull->getGeometryTypeId(), geos::geom::GEOS_POLYGON );
ensure_equals( hull->getDimension(), geos::geom::Dimension::A );
factory_.destroyGeometry(hull);
// FREE TESTED LINESTRING
factory_.destroyGeometry(line);
}
GeometryPtr createGeo(UInt32 mat)
{
GeoIndicesPtr ind = _ind[mat];
FDEBUG(("CreateGeoRec::createGeo: Mat %d: %d inds (%d tris)\n",
mat, ind->getSize(), ind->getSize()/3));
endEditCP(ind);
GeometryPtr geo = Geometry::create();
GeoPLengthsUI32Ptr len = GeoPLengthsUI32::create();
beginEditCP(len);
len->push_back(ind->getSize());
endEditCP(len);
GeoPTypesUI8Ptr typ = GeoPTypesUI8::create();
beginEditCP(typ);
typ->push_back(GL_TRIANGLES);
endEditCP(typ);
beginEditCP(geo);
if(random_color)
{
SimpleMaterialPtr mat = SimpleMaterial::create();
beginEditCP(mat);
Color3f c( drand48() * .7f + .3f,
drand48() * .7f + .3f,
drand48() * .7f + .3f);
mat->setDiffuse(c);
mat->setSpecular(Color3f(1.f,1.f,1.f));
mat->setShininess(10.f);
endEditCP(mat);
geo->setMaterial(mat);
}
else
{
geo->setMaterial(MaterialPool::getMaterial(mat));
}
geo->setPositions(_pos);
geo->setIndices(ind);
geo->setLengths(len);
geo->setTypes(typ);
geo->getIndexMapping().push_back(Geometry::MapPosition);
endEditCP(geo);
calcVertexNormals(geo);
//calcFaceNormals(geo);
createSingleIndex(geo);
return geo;
}
void object::test<18>()
{
PolygonPtr poly = factory_.createPolygon();
ensure( "createPolygon() returned null pointer.", poly != 0 );
ensure( "createPolygon() returned non-empty point.", poly->isEmpty() );
ensure( poly->isSimple() );
ensure( poly->isValid() );
ensure( poly->getCentroid() == 0 );
// TODO - mloskot - waiting for some decision
// http://geos.refractions.net/pipermail/geos-devel/2006-March/002006.html
//ensure( poly->getCoordinate() == 0 );
GeometryPtr geo = 0;
// TODO - mloskot - waiting for resolution
// http://geos.refractions.net/pipermail/geos-devel/2006-March/002011.html
//geo = poly->getEnvelope();
//ensure( geo != 0 );
//ensure( geo->isEmpty() );
//factory_.destroyGeometry(geo);
geo = poly->getBoundary();
ensure( geo != 0 );
ensure( geo->isEmpty() );
factory_.destroyGeometry(geo);
geo = poly->convexHull();
ensure( geo != 0 );
ensure( geo->isEmpty() );
factory_.destroyGeometry(geo);
ensure_equals( poly->getGeometryTypeId(), geos::geom::GEOS_POLYGON );
ensure_equals( poly->getDimension(), geos::geom::Dimension::A );
ensure_equals( poly->getBoundaryDimension(), geos::geom::Dimension::L );
ensure_equals( poly->getNumPoints(), 0u );
ensure_equals( poly->getLength(), 0.0 );
ensure_equals( poly->getArea(), 0.0 );
// FREE MEMORY
factory_.destroyGeometry(poly);
}
void SDFShadowDemo::BuildQuad()
{
// create a screen quad
m_pQuad = GeometryPtr(new GeometryDX11());
const i32 NumVertexOfQuad = 4;
// create the vertex element streams
VertexElementDX11* pPositions = new VertexElementDX11(3, NumVertexOfQuad);
pPositions->m_SemanticName = VertexElementDX11::PositionSemantic;
pPositions->m_uiSemanticIndex = 0;
pPositions->m_Format = DXGI_FORMAT_R32G32B32_FLOAT;
pPositions->m_uiInputSlot = 0;
pPositions->m_uiAlignedByteOffset = 0;
pPositions->m_InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
pPositions->m_uiInstanceDataStepRate = 0;
VertexElementDX11* pColors = new VertexElementDX11(4, NumVertexOfQuad);
pColors->m_SemanticName = VertexElementDX11::ColorSemantic;
pColors->m_uiSemanticIndex = 0;
pColors->m_Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
pColors->m_uiInputSlot = 0;
pColors->m_uiAlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
pColors->m_InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
pColors->m_uiInstanceDataStepRate = 0;
m_pQuad->AddElement(pPositions);
m_pQuad->AddElement(pColors);
*pPositions->Get3f(0) = Vector3f(-1.0f, +1.0f, 0.0f);
*pPositions->Get3f(1) = Vector3f(+1.0f, +1.0f, 0.0f);
*pPositions->Get3f(2) = Vector3f(-1.0f, -1.0f, 0.0f);
*pPositions->Get3f(3) = Vector3f(+1.0f, -1.0f, 0.0f);
*pColors->Get4f(0) = Colors::White;
*pColors->Get4f(1) = Colors::White;
*pColors->Get4f(2) = Colors::White;
*pColors->Get4f(3) = Colors::White;
m_pQuad->AddFace(TriangleIndices(0, 1, 2));
m_pQuad->AddFace(TriangleIndices(1, 3, 2));
m_pQuad->LoadToBuffers();
}
void object::test<7>()
{
GeometryPtr geo = factory_.createEmptyGeometry();
ensure( "createEmptyGeometry() returned null pointer.", geo != 0 );
ensure( "createEmptyGeometry() returned non-empty geometry.", geo->isEmpty() );
// TODO - mloskot
// http://geos.refractions.net/pipermail/geos-devel/2006-March/001960.html
/*
ensure( geo->isSimple() );
ensure( geo->isValid() );
ensure( geo->getCentroid() == 0 );
ensure( geo->getCoordinate() == 0 );
*/
// FREE MEMORY
factory_.destroyGeometry(geo);
}
void object::test<30>()
{
const size_t holesNum = 1;
GeometryPtr geo = nullptr;
geo = reader_.read("POLYGON ((0 0, 100 0, 100 100, 0 100, 0 0), (1 1, 1 10, 10 10, 10 1, 1 1) )");
ensure( geo != nullptr );
ensure_equals( geo->getGeometryTypeId(), geos::geom::GEOS_POLYGON );
PolygonPtr poly = dynamic_cast<PolygonPtr>(geo);
ensure( poly != nullptr );
ensure_equals( poly->getNumInteriorRing(), holesNum );
LineStringCPtr interior = poly->getInteriorRingN(0);
ensure( interior != nullptr );
ensure( interior->isRing() );
ensure_equals( interior->getGeometryTypeId(), geos::geom::GEOS_LINEARRING );
factory_->destroyGeometry(geo);
}
void object::test<15>()
{
LineStringPtr line = factory_.createLineString();
ensure( "createLineString() returned null pointer.", line != 0 );
ensure( "createLineString() returned non-empty point.", line->isEmpty() );
ensure( line->isSimple() );
ensure( line->isValid() );
ensure( line->getCentroid() == 0 );
// TODO - mloskot - waiting for some decision
// http://geos.refractions.net/pipermail/geos-devel/2006-March/002006.html
//ensure( line->getCoordinate() == 0 );
GeometryPtr geo = 0;
geo = line->getEnvelope();
ensure( geo != 0 );
ensure( geo->isEmpty() );
factory_.destroyGeometry(geo);
geo = line->getBoundary();
ensure( geo != 0 );
ensure( geo->isEmpty() );
factory_.destroyGeometry(geo);
geo = line->convexHull();
ensure( geo != 0 );
ensure( geo->isEmpty() );
factory_.destroyGeometry(geo);
ensure_equals( line->getGeometryTypeId(), geos::geom::GEOS_LINESTRING );
ensure_equals( line->getDimension(), geos::geom::Dimension::L );
ensure_equals( line->getBoundaryDimension(), geos::geom::Dimension::P ); // empty linestring
ensure_equals( line->getNumPoints(), 0u );
ensure_equals( line->getLength(), 0.0 );
ensure_equals( line->getArea(), 0.0 );
// FREE MEMORY
factory_.destroyGeometry(line);
}
QJsonObject JSonGeometryParser::toJSon(const GeometryPtr& geometry)
{
QJsonObject geometryJSon;
geometryJSon.insert(keys::geometryType, keys::typeMap.value(geometry->type()));
if (!geometry->points().isEmpty())
{
geometryJSon.insert(keys::coordinates,
::pointsToJSonArray(geometry->points(), geometry->type()));
}
if (!geometry->childGeometries().isEmpty())
{
QJsonArray childGeometryJSon;
for (const GeometryPtr& childGeometry: geometry->childGeometries())
{
childGeometryJSon.append(JSonGeometryParser::toJSon(childGeometry));
}
geometryJSon.insert(keys::geometries, childGeometryJSon);
}
return geometryJSon;
}
void object::test<24>()
{
MultiPointPtr mp = factory_.createMultiPoint();
ensure( "createMultiPoint() returned null pointer.", mp != 0 );
ensure( "createMultiPoint() returned non-empty point.", mp->isEmpty() );
ensure( mp->isSimple() );
ensure( mp->isValid() );
ensure( mp->getCentroid() == 0 );
GeometryPtr geo = 0;
// TODO - mloskot - waiting for resolution
// http://geos.refractions.net/pipermail/geos-devel/2006-March/002011.html
//geo = poly->getEnvelope();
//ensure( geo != 0 );
//ensure( geo->isEmpty() );
//factory_.destroyGeometry(geo);
geo = mp->getBoundary();
ensure( geo != 0 );
ensure( geo->isEmpty() );
factory_.destroyGeometry(geo);
geo = mp->convexHull();
ensure( geo != 0 );
ensure( geo->isEmpty() );
factory_.destroyGeometry(geo);
ensure_equals( mp->getGeometryTypeId(), geos::geom::GEOS_MULTIPOINT );
ensure_equals( mp->getDimension(), geos::geom::Dimension::P );
ensure_equals( mp->getBoundaryDimension(), geos::geom::Dimension::False );
ensure_equals( mp->getNumPoints(), 0u );
ensure_equals( mp->getLength(), 0.0 );
ensure_equals( mp->getArea(), 0.0 );
// FREE MEMORY
factory_.destroyGeometry(mp);
}
static NodePtr makePerturbedAll (UInt16 numSubdiv,
Real32 radius,
Real32 stdDeviation = 0.1f)
{
NodePtr sphereNode = makeSphere(numSubdiv, radius);
GeometryPtr sphere = GeometryPtr::dcast(sphereNode->getCore());
GeoPositionsPtr points = sphere->getPositions();
beginEditCP(points);
for (UInt32 i=0; i<points->size(); ++i) {
Real32 factor = 1.0f + stdDeviation * (rand()/Real32(RAND_MAX) - 0.5f);
points->setValue(factor*points->getValue(i), i);
}
endEditCP(points);
NodePtr node = Node::create();
beginEditCP(node);
node->setCore(Transform::create());
node->addChild(sphereNode);
endEditCP(node);
return node;
}
Action::ResultE changeGeo(NodePtr& node)
{
GeometryPtr geo = GeometryPtr::dcast(node->getCore());
if(geo == NullFC)
return Action::Continue;
GeoColors3fPtr colors = GeoColors3fPtr::dcast(geo->getColors());
if(colors == NullFC)
{
colors = GeoColors3f::create();
colors->resize(geo->getPositions()->getSize());
// Change the geometry to use the new colors
beginEditCP(geo, Geometry::ColorsFieldMask);
geo->setColors(colors);
// If multi-indexed, make the colors use the same index as
// the geometry
if(geo->getMFIndexMapping()->size() > 0)
{
Int16 pind = geo->calcMappingIndex(Geometry::MapPosition);
if(pind < 0)
{
FFATAL(("Multi-indexed, but no positions index???\n"));
return Action::Continue;
}
// This makes the colors use the same indices as the positions
geo->editIndexMapping(pind) |= Geometry::MapColor;
}
endEditCP (geo, Geometry::ColorsFieldMask);
}
beginEditCP(geo, Geometry::ColorsFieldMask);
beginEditCP(colors);
Real32 size = colors->getSize();
for(UInt32 i=0;i<size;++i)
{
Color3f c;
c[0] = ((Real32) i) / size;
c[1] = 0.0f;
c[2] = 0.0f;
colors->setValue(c, i);
}
endEditCP(colors);
endEditCP(geo, Geometry::ColorsFieldMask);
return Action::Continue;
}
void object::test<3>()
{
using geos::geom::GeometryFactory;
using geos::geom::CoordinateArraySequenceFactory;
CoordinateArraySequenceFactory csf;
{
GeometryFactory gf(&csf);
ensure_equals( gf.getSRID(), 0 );
ensure_equals( gf.getPrecisionModel()->getType(), geos::geom::PrecisionModel::FLOATING );
GeometryPtr geo = gf.createEmptyGeometry();
ensure( "createEmptyGeometry() returned null pointer.", geo != 0 );
ensure_equals( geo->getSRID() , gf.getSRID() );
ensure_equals( geo->getPrecisionModel()->getType(), geos::geom::PrecisionModel::FLOATING );
// FREE MEMORY
gf.destroyGeometry(geo);
}
// csf lifetime must exceed lifetime of the GeometryFactory instance
}
