void plot_loops (polygon_t * p, poly_dim_t speed, double flowrate, int dir)
{
if (!p)
return;
poly_contour_t *c;
for (c = p->contours; c; c = c->next)
if (c->vertices && (!dir || dir == c->dir))
{
poly_vertex_t *v = c->vertices;
poly_dim_t d = sqrtl ((px - v->x) * (px - v->x) + (py - v->y) * (py - v->y));
if (pe && d > layer * 5)
{ // hop and pull back extruder while moving
move (px, py, z + hop, back);
move (v->x, v->y, z + hop, back);
}
if (d)
move (v->x, v->y, z, 0);
double flow = (c->vertices->flag ? fillflow : 1);
for (v = c->vertices->next; v; v = v->next)
{
extrude (v->x, v->y, z, speed, flowrate * flow);
flow = (v->flag ? fillflow : 1);
}
if (c->dir)
{
v = c->vertices;
extrude (v->x, v->y, z, speed, flowrate * flow);
}
}
}
RectTorus::RectTorus(Geometry *g, qreal iRad, qreal oRad, qreal depth, int k)
{
QVector<QVector3D> inside;
QVector<QVector3D> outside;
for (int i = 0; i < k; ++i) {
qreal angle = (i * 2 * M_PI) / k;
inside << QVector3D(iRad * qSin(angle), iRad * qCos(angle), depth / 2.0);
outside << QVector3D(oRad * qSin(angle), oRad * qCos(angle), depth / 2.0);
}
inside << QVector3D(0.0, iRad, 0.0);
outside << QVector3D(0.0, oRad, 0.0);
QVector<QVector3D> in_back = extrude(inside, depth);
QVector<QVector3D> out_back = extrude(outside, depth);
// Create front, back and sides as separate patches so that smooth normals
// are generated for the curving sides, but a faceted edge is created between
// sides and front/back
Patch *front = new Patch(g);
for (int i = 0; i < k; ++i)
front->addQuad(outside[i], inside[i],
inside[(i + 1) % k], outside[(i + 1) % k]);
Patch *back = new Patch(g);
for (int i = 0; i < k; ++i)
back->addQuad(in_back[i], out_back[i],
out_back[(i + 1) % k], in_back[(i + 1) % k]);
Patch *is = new Patch(g);
for (int i = 0; i < k; ++i)
is->addQuad(in_back[i], in_back[(i + 1) % k],
inside[(i + 1) % k], inside[i]);
Patch *os = new Patch(g);
for (int i = 0; i < k; ++i)
os->addQuad(out_back[(i + 1) % k], out_back[i],
outside[i], outside[(i + 1) % k]);
parts << front << back << is << os;
}
GLuint GLWidget::makeObject()
{
GLuint list = glGenLists(1);
glNewList(list, GL_COMPILE);
glBegin(GL_QUADS);
GLdouble x1 = +0.06;
GLdouble y1 = -0.14;
GLdouble x2 = +0.14;
GLdouble y2 = -0.06;
GLdouble x3 = +0.08;
GLdouble y3 = +0.00;
GLdouble x4 = +0.30;
GLdouble y4 = +0.22;
quad(x1, y1, x2, y2, y2, x2, y1, x1);
quad(x3, y3, x4, y4, y4, x4, y3, x3);
extrude(x1, y1, x2, y2);
extrude(x2, y2, y2, x2);
extrude(y2, x2, y1, x1);
extrude(y1, x1, x1, y1);
extrude(x3, y3, x4, y4);
extrude(x4, y4, y4, x4);
extrude(y4, x4, y3, x3);
const double Pi = 3.14159265358979323846;
const int NumSectors = 200;
for (int i = 0; i < NumSectors; ++i) {
double angle1 = (i * 2 * Pi) / NumSectors;
GLdouble x5 = 0.30 * sin(angle1);
GLdouble y5 = 0.30 * cos(angle1);
GLdouble x6 = 0.20 * sin(angle1);
GLdouble y6 = 0.20 * cos(angle1);
double angle2 = ((i + 1) * 2 * Pi) / NumSectors;
GLdouble x7 = 0.20 * sin(angle2);
GLdouble y7 = 0.20 * cos(angle2);
GLdouble x8 = 0.30 * sin(angle2);
GLdouble y8 = 0.30 * cos(angle2);
quad(x5, y5, x6, y6, x7, y7, x8, y8);
extrude(x6, y6, x7, y7);
extrude(x8, y8, x5, y5);
}
glEnd();
glEndList();
return list;
}
void Make_CallListes(){
// Objet par extrusion : segment
glNewList(OBJET_1,GL_COMPILE);
glPushMatrix();
glScalef(0.5f,0.8f,0.5f);
glTranslatef(-2.0f,0.0f,-1.0f);
extrude(9, segment_2d, extrusion_vector);
glPopMatrix();
glEndList();
// Objet par extrusion : pince
glNewList(OBJET_2,GL_COMPILE);
glPushMatrix();
glScalef(0.2f,0.3f,0.2f);
glTranslatef(0.0f,0.0f,-1.0f);
extrude(15, pince_2d, extrusion_vector);
glPopMatrix();
glEndList();
// Objet par revoltion : base
glNewList(OBJET_3,GL_COMPILE);
glPushMatrix();
glScalef(0.25f,0.25f,0.25f);
revolution(6, base_2d, 360, 16);
glPopMatrix();
glEndList();
// Objet par revoltion : pied de table
glNewList(OBJET_4,GL_COMPILE);
glPushMatrix();
glScalef(0.3f,0.4f,0.3f);
revolution(7, pied_2d, 360, 16);
glPopMatrix();
glEndList();
// Objet chargé : articulation (sphère)
glNewList(OBJET_5,GL_COMPILE);
DessinModele();
glEndList();
}
Solid * extrude( const Polygon & g, const Kernel::Vector_3 & v )
{
BOOST_ASSERT( ! g.isEmpty() );
bool reverseOrientation = ( v * normal3D< Kernel >( g ) ) > 0 ;
//resulting shell
PolyhedralSurface polyhedralSurface ;
// "bottom"
Polygon bottom(g);
force3D( bottom ) ;
if ( reverseOrientation ){
bottom.reverse();
}
polyhedralSurface.addPolygon( bottom );
// "top"
Polygon top( bottom );
top.reverse() ;
translate(top,v);
polyhedralSurface.addPolygon( top );
// exterior ring and interior rings extruded
for ( size_t i = 0; i < bottom.numRings(); i++ ){
std::auto_ptr< PolyhedralSurface > boundaryExtruded( extrude( bottom.ringN(i), v ) );
for ( size_t j = 0; j < boundaryExtruded->numPolygons(); j++ ){
boundaryExtruded->polygonN(j).reverse() ;
polyhedralSurface.addPolygon( boundaryExtruded->polygonN(j) ) ;
}
}
return new Solid( polyhedralSurface );
}
Solid* extrude( const TriangulatedSurface& g, const Kernel::Vector_3& v )
{
std::auto_ptr< Solid > result( new Solid() );
//bottom and top
for ( size_t i = 0; i < g.numGeometries(); i++ ) {
Triangle bottomPart( g.geometryN( i ) );
force3D( bottomPart );
bottomPart.reverse() ;
result->exteriorShell().addPolygon( bottomPart );
Triangle topPart( g.geometryN( i ) );
force3D( topPart );
translate( topPart, v );
result->exteriorShell().addPolygon( topPart );
}
//boundary
std::auto_ptr< Geometry > boundary( g.boundary() ) ;
BOOST_ASSERT( boundary.get() != NULL );
// closed surface extruded
if ( ! boundary->isEmpty() ) {
std::auto_ptr< Geometry > extrudedBoundary( extrude( *boundary, v ) ) ;
BOOST_ASSERT( extrudedBoundary->is< PolyhedralSurface >() );
result->exteriorShell().addPolygons( extrudedBoundary->as< PolyhedralSurface >() );
}
return result.release() ;
}
RectPrism::RectPrism(Geometry *g, qreal width, qreal height, qreal depth)
{
enum { bl, br, tr, tl };
Patch *fb = new Patch(g);
fb->setSmoothing(Patch::Faceted);
// front face
QVector<QVector3D> r(4);
r[br].setX(width);
r[tr].setX(width);
r[tr].setY(height);
r[tl].setY(height);
QVector3D adjToCenter(-width / 2.0, -height / 2.0, depth / 2.0);
for (int i = 0; i < 4; ++i)
r[i] += adjToCenter;
fb->addQuad(r[bl], r[br], r[tr], r[tl]);
// back face
QVector<QVector3D> s = extrude(r, depth);
fb->addQuad(s[tl], s[tr], s[br], s[bl]);
// side faces
Patch *sides = new Patch(g);
sides->setSmoothing(Patch::Faceted);
sides->addQuad(s[bl], s[br], r[br], r[bl]);
sides->addQuad(s[br], s[tr], r[tr], r[br]);
sides->addQuad(s[tr], s[tl], r[tl], r[tr]);
sides->addQuad(s[tl], s[bl], r[bl], r[tl]);
parts << fb << sides;
}
SFCGAL_API std::auto_ptr< Geometry > extrude( const Geometry& g, const double& dx, const double& dy, const double& dz )
{
if ( !std::isfinite( dx ) || !std::isfinite( dy ) || !std::isfinite( dz ) ) {
BOOST_THROW_EXCEPTION( NonFiniteValueException( "trying to extrude with non finite value in direction" ) );
}
return extrude( g, Kernel::FT( dx ), Kernel::FT( dy ), Kernel::FT( dz ) );
}
MultiSolid * extrude( const MultiPolygon & g, const Kernel::Vector_3 & v )
{
std::auto_ptr< MultiSolid > result( new MultiSolid() );
for ( size_t i = 0; i < g.numGeometries(); i++ ){
result->addGeometry( extrude( g.polygonN(i), v ) );
}
return result.release() ;
}
MultiLineString * extrude( const MultiPoint & g, const Kernel::Vector_3 & v )
{
std::auto_ptr< MultiLineString > result( new MultiLineString() );
for ( size_t i = 0; i < g.numGeometries(); i++ ){
result->addGeometry( extrude( g.pointN(i), v ) );
}
return result.release() ;
}
GeometryCollection* extrude( const GeometryCollection & g, const Kernel::Vector_3 & v )
{
std::auto_ptr< GeometryCollection > result( new GeometryCollection() ) ;
for ( size_t i = 0; i < g.numGeometries(); i++ ){
result->addGeometry( extrude( g.geometryN(i), v ).release() );
}
return result.release() ;
}
void Renderer::createGeometry()
{
vertices.clear();
normals.clear();
qreal x1 = +0.06f;
qreal y1 = -0.14f;
qreal x2 = +0.14f;
qreal y2 = -0.06f;
qreal x3 = +0.08f;
qreal y3 = +0.00f;
qreal x4 = +0.30f;
qreal y4 = +0.22f;
quad(x1, y1, x2, y2, y2, x2, y1, x1);
quad(x3, y3, x4, y4, y4, x4, y3, x3);
extrude(x1, y1, x2, y2);
extrude(x2, y2, y2, x2);
extrude(y2, x2, y1, x1);
extrude(y1, x1, x1, y1);
extrude(x3, y3, x4, y4);
extrude(x4, y4, y4, x4);
extrude(y4, x4, y3, x3);
const qreal Pi = 3.14159f;
const int NumSectors = 100;
for (int i = 0; i < NumSectors; ++i) {
qreal angle1 = (i * 2 * Pi) / NumSectors;
qreal x5 = 0.30 * sin(angle1);
qreal y5 = 0.30 * cos(angle1);
qreal x6 = 0.20 * sin(angle1);
qreal y6 = 0.20 * cos(angle1);
qreal angle2 = ((i + 1) * 2 * Pi) / NumSectors;
qreal x7 = 0.20 * sin(angle2);
qreal y7 = 0.20 * cos(angle2);
qreal x8 = 0.30 * sin(angle2);
qreal y8 = 0.30 * cos(angle2);
quad(x5, y5, x6, y6, x7, y7, x8, y8);
extrude(x6, y6, x7, y7);
extrude(x8, y8, x5, y5);
}
for (int i = 0;i < vertices.size();i++)
vertices[i] *= 2.0f;
}
Logo::Logo()
: m_count(0)
{
m_data.resize(2500 * 6);
const GLfloat x1 = +0.06f;
const GLfloat y1 = -0.14f;
const GLfloat x2 = +0.14f;
const GLfloat y2 = -0.06f;
const GLfloat x3 = +0.08f;
const GLfloat y3 = +0.00f;
const GLfloat x4 = +0.30f;
const GLfloat y4 = +0.22f;
quad(x1, y1, x2, y2, y2, x2, y1, x1);
quad(x3, y3, x4, y4, y4, x4, y3, x3);
extrude(x1, y1, x2, y2);
extrude(x2, y2, y2, x2);
extrude(y2, x2, y1, x1);
extrude(y1, x1, x1, y1);
extrude(x3, y3, x4, y4);
extrude(x4, y4, y4, x4);
extrude(y4, x4, y3, x3);
const int NumSectors = 100;
for (int i = 0; i < NumSectors; ++i) {
GLfloat angle = (i * 2 * M_PI) / NumSectors;
GLfloat angleSin = qSin(angle);
GLfloat angleCos = qCos(angle);
const GLfloat x5 = 0.30f * angleSin;
const GLfloat y5 = 0.30f * angleCos;
const GLfloat x6 = 0.20f * angleSin;
const GLfloat y6 = 0.20f * angleCos;
angle = ((i + 1) * 2 * M_PI) / NumSectors;
angleSin = qSin(angle);
angleCos = qCos(angle);
const GLfloat x7 = 0.20f * angleSin;
const GLfloat y7 = 0.20f * angleCos;
const GLfloat x8 = 0.30f * angleSin;
const GLfloat y8 = 0.30f * angleCos;
quad(x5, y5, x6, y6, x7, y7, x8, y8);
extrude(x6, y6, x7, y7);
extrude(x8, y8, x5, y5);
}
}
HECube::HECube(vec3 Scale, vec3 Rotate, float RotAngle, vec3 Translate) : HEExtrusion(Scale, Rotate, RotAngle, Translate)
{
VertLine base;
base.addVertex(vec4(-0.5, 0, -0.5, 0));
base.addVertex(vec4(-0.5, 0, 0.5, 0));
base.addVertex(vec4(0.5, 0, 0.5, 0));
base.addVertex(vec4(0.5, 0, -0.5, 0));
extrude(base);
}
Solid* extrude( const PolyhedralSurface& g, const Kernel::Vector_3& v )
{
if ( g.isEmpty() ) {
return new Solid();
}
TriangulatedSurface triangulatedSurface ;
triangulate::triangulatePolygon3D( g, triangulatedSurface );
return extrude( triangulatedSurface, v ) ;
}
std::auto_ptr< Geometry > extrude( const Geometry& g, const Kernel::Vector_3& v )
{
switch ( g.geometryTypeId() ) {
case TYPE_POINT:
return std::auto_ptr< Geometry >( extrude( g.as< Point >(), v ) );
case TYPE_LINESTRING:
return std::auto_ptr< Geometry >( extrude( g.as< LineString >(), v ) );
case TYPE_POLYGON:
return std::auto_ptr< Geometry >( extrude( g.as< Polygon >(), v ) );
case TYPE_TRIANGLE:
return std::auto_ptr< Geometry >( extrude( g.as< Triangle >(), v ) );
case TYPE_GEOMETRYCOLLECTION:
return std::auto_ptr< Geometry >( extrude( g.as< GeometryCollection >(), v ) );
case TYPE_MULTIPOINT:
return std::auto_ptr< Geometry >( extrude( g.as< MultiPoint >(), v ) );
case TYPE_MULTILINESTRING:
return std::auto_ptr< Geometry >( extrude( g.as< MultiLineString >(), v ) );
case TYPE_MULTIPOLYGON:
return std::auto_ptr< Geometry >( extrude( g.as< MultiPolygon >(), v ) );
case TYPE_TRIANGULATEDSURFACE:
return std::auto_ptr< Geometry >( extrude( g.as< TriangulatedSurface >(), v ) );
case TYPE_POLYHEDRALSURFACE:
return std::auto_ptr< Geometry >( extrude( g.as< PolyhedralSurface >(), v ) );
case TYPE_SOLID:
case TYPE_MULTISOLID:
//extrusion not available
break;
}
BOOST_THROW_EXCEPTION( InappropriateGeometryException(
( boost::format( "unexpected GeometryType in extrude ('%1%')" ) % g.geometryType() ).str()
) );
}
PolyhedralSurface * extrude( const MultiLineString & g, const Kernel::Vector_3 & v )
{
std::auto_ptr< PolyhedralSurface > result( new PolyhedralSurface() );
for ( size_t i = 0; i < g.numGeometries(); i++ ){
std::auto_ptr< PolyhedralSurface > extruded( extrude( g.lineStringN(i), v ) );
for ( size_t j = 0; j < extruded->numPolygons(); j++ ){
result->addPolygon( extruded->polygonN(j) );
}
}
return result.release() ;
}
osg::ref_ptr<osg::Group> MapExtruder::osg_assemble()
{
osg::ref_ptr<osg::Group> osg = new osg::Group;
osg::ref_ptr<osg::Node> surface = osgDB::readNodeFile(_map2dFile);
ExtrudeVisitor extrude(_height);
surface->accept(extrude);
osg->addChild(surface);
int n = _sides ->getNumGeometries();
osg::ref_ptr<osg::Geode> geode = new osg::Geode;
for(int i=0;i<n;i++)
{
osg::ref_ptr<osg::Geometry> geom = new osg::Geometry;
osg::ref_ptr<osg::Vec3Array> verts = new osg::Vec3Array;
std::vector<OGRPoint> points;
OGRLinearRing *ring = ((OGRPolygon*)_sides->getGeometryRef(i))->getExteriorRing();
int m = ring->getNumPoints();
for(int j=0;j<m;j++)
{
OGRPoint pt;
ring->getPoint(j,&pt);
verts->push_back(osg::Vec3(pt.getX(),pt.getY(),pt.getZ()));
}
geom->setVertexArray(verts);
osg::Vec4Array* colors = new osg::Vec4Array;
colors->push_back(YELLOW);
geom->setColorArray(colors);
geom->setColorBinding(osg::Geometry::BIND_OVERALL);
geom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::POLYGON,0,m));
geode->addDrawable(geom);
}
osg->addChild(geode);
return osg;
}
int main(int argc, char **argv) {
typedef std::vector<carve::geom2d::P2> loop_t;
std::ifstream in(argv[1]);
unsigned file_num = 0;
while (in.good()) {
std::string s;
std::getline(in, s);
if (in.eof()) break;
std::vector<std::vector<carve::geom2d::P2> > paths;
parsePath(s, paths);
std::cerr << "paths.size()=" << paths.size() << std::endl;
if (paths.size() > 1) {
std::vector<std::vector<std::pair<size_t, size_t> > > result;
std::vector<std::vector<carve::geom2d::P2> > merged;
result = carve::triangulate::mergePolygonsAndHoles(paths);
merged.resize(result.size());
for (size_t i = 0; i < result.size(); ++i) {
std::vector<std::pair<size_t, size_t> > &p = result[i];
merged[i].reserve(p.size());
for (size_t j = 0; j < p.size(); ++j) {
merged[i].push_back(paths[p[j].first][p[j].second]);
}
}
paths.swap(merged);
}
carve::poly::Polyhedron *p = extrude(paths, carve::geom::VECTOR(0,0,100));
p->transform(carve::math::Matrix::TRANS(-p->aabb.pos));
std::ostringstream outf;
outf << "file_" << file_num++ << ".ply";
std::ofstream out(outf.str().c_str());
writePLY(out, p, false);
delete p;
}
return 0;
}
int HullLibrary::calchullgen(btVector3 *verts,int verts_count, int vlimit)
{
if(verts_count <4) return 0;
if(vlimit==0) vlimit=1000000000;
int j;
btVector3 bmin(*verts),bmax(*verts);
btAlignedObjectArray<int> isextreme;
isextreme.reserve(verts_count);
btAlignedObjectArray<int> allow;
allow.reserve(verts_count);
for(j=0;j<verts_count;j++)
{
allow.push_back(1);
isextreme.push_back(0);
bmin.setMin (verts[j]);
bmax.setMax (verts[j]);
}
btScalar epsilon = (bmax-bmin).length() * btScalar(0.001);
btAssert (epsilon != 0.0);
int4 p = FindSimplex(verts,verts_count,allow);
if(p.x==-1) return 0; // simplex failed
btVector3 center = (verts[p[0]]+verts[p[1]]+verts[p[2]]+verts[p[3]]) / btScalar(4.0); // a valid interior point
btHullTriangle *t0 = allocateTriangle(p[2],p[3],p[1]); t0->n=int3(2,3,1);
btHullTriangle *t1 = allocateTriangle(p[3],p[2],p[0]); t1->n=int3(3,2,0);
btHullTriangle *t2 = allocateTriangle(p[0],p[1],p[3]); t2->n=int3(0,1,3);
btHullTriangle *t3 = allocateTriangle(p[1],p[0],p[2]); t3->n=int3(1,0,2);
isextreme[p[0]]=isextreme[p[1]]=isextreme[p[2]]=isextreme[p[3]]=1;
checkit(t0);checkit(t1);checkit(t2);checkit(t3);
for(j=0;j<m_tris.size();j++)
{
btHullTriangle *t=m_tris[j];
btAssert(t);
btAssert(t->vmax<0);
btVector3 n=TriNormal(verts[(*t)[0]],verts[(*t)[1]],verts[(*t)[2]]);
t->vmax = maxdirsterid(verts,verts_count,n,allow);
t->rise = dot(n,verts[t->vmax]-verts[(*t)[0]]);
}
btHullTriangle *te;
vlimit-=4;
while(vlimit >0 && ((te=extrudable(epsilon)) != 0))
{
int3 ti=*te;
int v=te->vmax;
btAssert(v != -1);
btAssert(!isextreme[v]); // wtf we've already done this vertex
isextreme[v]=1;
//if(v==p0 || v==p1 || v==p2 || v==p3) continue; // done these already
j=m_tris.size();
while(j--) {
if(!m_tris[j]) continue;
int3 t=*m_tris[j];
if(above(verts,t,verts[v],btScalar(0.01)*epsilon))
{
extrude(m_tris[j],v);
}
}
// now check for those degenerate cases where we have a flipped triangle or a really skinny triangle
j=m_tris.size();
while(j--)
{
if(!m_tris[j]) continue;
if(!hasvert(*m_tris[j],v)) break;
int3 nt=*m_tris[j];
if(above(verts,nt,center,btScalar(0.01)*epsilon) || cross(verts[nt[1]]-verts[nt[0]],verts[nt[2]]-verts[nt[1]]).length()< epsilon*epsilon*btScalar(0.1) )
{
btHullTriangle *nb = m_tris[m_tris[j]->n[0]];
btAssert(nb);btAssert(!hasvert(*nb,v));btAssert(nb->id<j);
extrude(nb,v);
j=m_tris.size();
}
}
j=m_tris.size();
while(j--)
{
btHullTriangle *t=m_tris[j];
if(!t) continue;
if(t->vmax>=0) break;
btVector3 n=TriNormal(verts[(*t)[0]],verts[(*t)[1]],verts[(*t)[2]]);
t->vmax = maxdirsterid(verts,verts_count,n,allow);
if(isextreme[t->vmax])
{
t->vmax=-1; // already done that vertex - algorithm needs to be able to terminate.
}
else
{
t->rise = dot(n,verts[t->vmax]-verts[(*t)[0]]);
}
}
vlimit --;
}
return 1;
}
Solid* extrude( const Triangle& g, const Kernel::Vector_3& v )
{
BOOST_ASSERT( ! g.isEmpty() );
return extrude( g.toPolygon(), v );
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct {
struct Option *input, *output, *zshift, *height, *elevation, *hcolumn,
*type, *field, *cats, *where, *interp, *scale, *null;
} opt;
struct {
struct Flag *trace;
} flag;
struct Map_info In, Out;
struct line_pnts *Points;
struct line_cats *Cats;
struct bound_box map_box;
struct cat_list *cat_list;
struct Cell_head window;
int field;
int only_type, cat;
int fdrast, interp_method, trace;
double objheight, objheight_default, voffset;
double scale, null_val;
struct field_info *Fi;
dbDriver *driver = NULL;
char *comment;
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("geometry"));
G_add_keyword(_("sampling"));
G_add_keyword(_("3D"));
module->label =
_("Extrudes flat vector features to 3D vector features with defined height.");
module->description =
_("Optionally the height can be derived from sampling of elevation raster map.");
flag.trace = G_define_flag();
flag.trace->key = 't';
flag.trace->description = _("Trace elevation");
flag.trace->guisection = _("Elevation");
opt.input = G_define_standard_option(G_OPT_V_INPUT);
opt.field = G_define_standard_option(G_OPT_V_FIELD_ALL);
opt.field->guisection = _("Selection");
opt.cats = G_define_standard_option(G_OPT_V_CATS);
opt.cats->guisection = _("Selection");
opt.where = G_define_standard_option(G_OPT_DB_WHERE);
opt.where->guisection = _("Selection");
opt.type = G_define_standard_option(G_OPT_V_TYPE);
opt.type->answer = "point,line,area";
opt.type->options = "point,line,area";
opt.type->guisection = _("Selection");
opt.output = G_define_standard_option(G_OPT_V_OUTPUT);
opt.zshift = G_define_option();
opt.zshift->key = "zshift";
opt.zshift->description = _("Shifting value for z coordinates");
opt.zshift->type = TYPE_DOUBLE;
opt.zshift->required = NO;
opt.zshift->answer = "0";
opt.zshift->guisection = _("Height");
opt.height = G_define_option();
opt.height->key = "height";
opt.height->type = TYPE_DOUBLE;
opt.height->required = NO;
opt.height->multiple = NO;
opt.height->description = _("Fixed height for 3D vector features");
opt.height->guisection = _("Height");
opt.hcolumn = G_define_standard_option(G_OPT_DB_COLUMN);
opt.hcolumn->key = "height_column";
opt.hcolumn->multiple = NO;
opt.hcolumn->description = _("Name of attribute column with feature height");
opt.hcolumn->guisection = _("Height");
/* raster sampling */
opt.elevation = G_define_standard_option(G_OPT_R_ELEV);
opt.elevation->required = NO;
opt.elevation->description = _("Elevation raster map for height extraction");
opt.elevation->guisection = _("Elevation");
opt.interp = G_define_standard_option(G_OPT_R_INTERP_TYPE);
opt.interp->answer = "nearest";
opt.interp->guisection = _("Elevation");
opt.scale = G_define_option();
opt.scale->key = "scale";
opt.scale->type = TYPE_DOUBLE;
opt.scale->description = _("Scale factor sampled raster values");
opt.scale->answer = "1.0";
opt.scale->guisection = _("Elevation");
opt.null = G_define_option();
opt.null->key = "null_value";
opt.null->type = TYPE_DOUBLE;
opt.null->description =
_("Height for sampled raster NULL values");
opt.null->guisection = _("Elevation");
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (!opt.height->answer && !opt.hcolumn->answer) {
G_fatal_error(_("One of '%s' or '%s' parameters must be set"),
opt.height->key, opt.hcolumn->key);
}
sscanf(opt.zshift->answer, "%lf", &voffset);
G_debug(1, "voffset = %f", voffset);
if (opt.height->answer)
sscanf(opt.height->answer, "%lf", &objheight);
else
objheight = 0.;
G_debug(1, "objheight = %f", objheight);
objheight_default = objheight;
only_type = Vect_option_to_types(opt.type);
/* sampling method */
interp_method = Rast_option_to_interp_type(opt.interp);
/* used to scale sampled raster values */
scale = atof(opt.scale->answer);
/* is null value defined */
if (opt.null->answer)
null_val = atof(opt.null->answer);
/* trace elevation */
trace = flag.trace->answer ? TRUE : FALSE;
/* set input vector map name and mapset */
Vect_check_input_output_name(opt.input->answer, opt.output->answer, G_FATAL_EXIT);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_set_open_level(2); /* topology required for input */
/* opening input vector map */
if (Vect_open_old2(&In, opt.input->answer, "", opt.field->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), opt.input->answer);
Vect_set_error_handler_io(&In, &Out);
/* creating output vector map */
if (Vect_open_new(&Out, opt.output->answer, WITH_Z) < 0)
G_fatal_error(_("Unable to create vector map <%s>"),
opt.output->answer);
field = Vect_get_field_number(&In, opt.field->answer);
if ((opt.hcolumn->answer || opt.cats->answer || opt.where->answer) && field == -1) {
G_warning(_("Invalid layer number (%d). "
"Parameter '%s', '%s' or '%s' specified, assuming layer '1'."),
field, opt.hcolumn->key, opt.cats->key, opt.where->key);
field = 1;
}
/* set constraint for cats or where */
cat_list = NULL;
if (field > 0)
cat_list = Vect_cats_set_constraint(&In, field, opt.where->answer,
opt.cats->answer);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
/* opening database connection, if required */
if (opt.hcolumn->answer) {
int ctype;
dbColumn *column;
if ((Fi = Vect_get_field(&In, field)) == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
field);
if ((driver =
db_start_driver_open_database(Fi->driver, Fi->database)) == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
db_set_error_handler_driver(driver);
if (db_get_column(driver, Fi->table, opt.hcolumn->answer, &column) != DB_OK)
G_fatal_error(_("Column <%s> does not exist"),
opt.hcolumn->answer);
else
db_free_column(column);
ctype = db_column_Ctype(driver, Fi->table, opt.hcolumn->answer);
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_STRING &&
ctype != DB_C_TYPE_DOUBLE) {
G_fatal_error(_("Column <%s>: invalid data type"),
opt.hcolumn->answer);
}
}
/* do we work with elevation raster? */
fdrast = -1;
if (opt.elevation->answer) {
/* raster setup */
G_get_window(&window);
/* open the elev raster, and check for error condition */
fdrast = Rast_open_old(opt.elevation->answer, "");
}
/* if area */
if (only_type & GV_AREA) {
int area, nareas, centroid;
nareas = Vect_get_num_areas(&In);
G_debug(2, "n_areas = %d", nareas);
if (nareas > 0)
G_message(_("Extruding areas..."));
for (area = 1; area <= nareas; area++) {
G_debug(3, "area = %d", area);
G_percent(area, nareas, 2);
if (!Vect_area_alive(&In, area))
continue;
centroid = Vect_get_area_centroid(&In, area);
if (!centroid) {
G_warning(_("Skipping area %d without centroid"), area);
continue;
}
Vect_read_line(&In, NULL, Cats, centroid);
if (field > 0 && !Vect_cats_in_constraint(Cats, field, cat_list))
continue;
/* height attribute */
if (opt.hcolumn->answer) {
cat = Vect_get_area_cat(&In, area, field);
if (cat == -1) {
G_warning(_("No category defined for area %d. Using default fixed height %f."),
area, objheight_default);
objheight = objheight_default;
}
if (get_height(Fi, opt.hcolumn->answer,
driver, cat, &objheight) != 0) {
G_warning(_("Unable to fetch height from DB for area %d. Using default fixed height %f."),
area, objheight_default);
objheight = objheight_default;
}
} /* if opt.hcolumn->answer */
Vect_get_area_points(&In, area, Points);
G_debug(3, "area: %d height: %f", area, objheight);
extrude(&In, &Out, Cats, Points,
fdrast, trace, interp_method, scale,
opt.null->answer ? TRUE : FALSE, null_val,
objheight, voffset, &window, GV_AREA,
centroid);
} /* foreach area */
}
if (only_type > 0) {
int line, nlines;
int type;
G_debug(1, "other than areas");
/* loop through each line in the dataset */
nlines = Vect_get_num_lines(&In);
G_message(_("Extruding features..."));
for (line = 1; line <= nlines; line++) {
/* progress feedback */
G_percent(line, nlines, 2);
if (!Vect_line_alive(&In, line))
continue;
/* read line */
type = Vect_read_line(&In, Points, Cats, line);
if (!(type & only_type))
continue;
if (field > 0 && !Vect_cats_in_constraint(Cats, field, cat_list))
continue;
/* height attribute */
if (opt.hcolumn->answer) {
cat = Vect_get_line_cat(&In, line, field);
if (cat == -1) {
G_warning(_("No category defined for feature %d. Using default fixed height %f."),
line, objheight_default);
objheight = objheight_default;
}
if (get_height(Fi, opt.hcolumn->answer,
driver, cat, &objheight) != 0) {
G_warning(_("Unable to fetch height from DB for line %d. Using default fixed height %f."),
line, objheight_default);
objheight = objheight_default;
}
} /* if opt.hcolumn->answer */
extrude(&In, &Out, Cats, Points,
fdrast, trace, interp_method, scale,
opt.null->answer ? TRUE : FALSE, null_val,
objheight, voffset, &window, type, -1);
} /* for each line */
} /* else if area */
if (driver) {
db_close_database(driver);
db_shutdown_driver(driver);
}
G_important_message(_("Copying attribute table..."));
if (field < 0)
Vect_copy_tables(&In, &Out, 0);
else
Vect_copy_table_by_cat_list(&In, &Out, field, field, NULL,
GV_1TABLE, cat_list);
Vect_build(&Out);
/* header */
G_asprintf(&comment, "Generated by %s from vector map <%s>",
G_program_name(), Vect_get_full_name(&In));
Vect_set_comment(&Out, comment);
G_free(comment);
Vect_get_map_box(&Out, &map_box);
Vect_close(&In);
Vect_close(&Out);
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
G_done_msg("T: %f B: %f.", map_box.T, map_box.B);
exit(EXIT_SUCCESS);
}
std::auto_ptr< Geometry > extrude( const Geometry& g, Kernel::FT dx, Kernel::FT dy, Kernel::FT dz )
{
SFCGAL_ASSERT_GEOMETRY_VALIDITY( g );
return extrude( g, dx, dy, dz, NoValidityCheck() );
}
Solid* extrude( const PolyhedralSurface& g, const Kernel::Vector_3& v )
{
TriangulatedSurface triangulatedSurface ;
triangulate::triangulatePolygon3D( g, triangulatedSurface );
return extrude( triangulatedSurface, v ) ;
}
Solid* extrude( const Triangle& g, const Kernel::Vector_3& v )
{
return extrude( g.toPolygon(), v );
}
std::auto_ptr< Geometry > extrude( const Geometry& g, Kernel::FT dx, Kernel::FT dy, Kernel::FT dz, NoValidityCheck )
{
return extrude( g, Kernel::Vector_3( dx,dy,dz ) ) ;
}
int main(int argc, char *argv[])
{
if (argc < 2) {
std::cerr << "Need Resource Dir !" << std::endl;
return 1;
}
// if (argc < 3) {
// std::cerr << "Need Resource Dir & Extrude size !" << std::endl;
// return 1;
// }
std::string dirpath = argv[1];
wxArrayString files;
DirTraverser traverser(files);
wxDir dir(dirpath);
dir.Traverse(traverser);
std::map<std::string, ee::Rect> map_name2rect;
double size = 1;
// wxString(argv[2]).ToDouble(&size);
try {
for (size_t i = 0, n = files.size(); i < n; ++i)
{
wxFileName filename(files[i]);
filename.Normalize();
wxString filepath = filename.GetFullPath();
if (ee::FileNameParser::isType(filepath, ee::FileNameParser::e_image))
{
coceditor::ExtrudeImg extrude(filepath.ToStdString());
extrude.Trigger((int)size);
map_name2rect.insert(std::make_pair(extrude.GetFileName(), extrude.GetRectTrimed()));
}
}
for (size_t i = 0, n= files.size(); i < n; ++i)
{
wxFileName filename(files[i]);
filename.Normalize();
wxString filepath = filename.GetFullPath();
if (ee::FileNameParser::isType(filepath, ee::FileNameParser::e_complex))
{
Json::Value value;
Json::Reader reader;
std::locale::global(std::locale(""));
std::ifstream fin(filepath.fn_str());
std::locale::global(std::locale("C"));
reader.parse(fin, value);
fin.close();
bool dirty = false;
int i = 0;
Json::Value spriteValue = value["sprite"][i++];
while (!spriteValue.isNull()) {
std::string path = spriteValue["filepath"].asString();
path = ee::FilenameTools::getFilenameWithExtension(path);
std::map<std::string, ee::Rect>::iterator itr = map_name2rect.find(path);
if (itr != map_name2rect.end()) {
dirty = true;
const float x = spriteValue["position"]["x"].asDouble(),
y = spriteValue["position"]["y"].asDouble();
value["sprite"][i-1]["position"]["x"] = x + itr->second.xCenter() * spriteValue["x scale"].asDouble();
value["sprite"][i-1]["position"]["y"] = y + itr->second.yCenter() * spriteValue["y scale"].asDouble();
}
spriteValue = value["sprite"][i++];
}
if (dirty)
{
Json::StyledStreamWriter writer;
std::locale::global(std::locale(""));
std::ofstream fout(filepath.fn_str());
std::locale::global(std::locale("C"));
writer.write(fout, value);
fout.close();
}
}
}
} catch (ee::Exception& e) {
std::cerr << e.what() << std::endl;
}
return 0;
}
