Ejemplo n.º 1
0
Archivo: map.cpp Proyecto: Metalab/CGSG
void freePolygonList(PolygonList& list) {
  PolygonList::iterator begin = list.begin(), end=list.end();
  for(; begin != end; begin++)
    delete *begin;

  list.clear();
}
Ejemplo n.º 2
0
void polygonList2File(PolygonList & p, ftFile ff)
{
	ff.write("");
	for (auto it = p.begin(); it != p.end(); ++it) {
                polygon2File(*it, ff);
	}
}
Ejemplo n.º 3
0
void SpatiaLiteDB::queryGeometry(
		std::string table,
		std::string geometry_col,
		double left,
		double bottom,
		double right,
		double top,
		std::string label_col) {

	_pointlist.clear();
	_linestringlist.clear();
	_polygonlist.clear();
	bool getLabel = label_col.size() != 0;

	// Search for geometry and name

	// The query will be either
	//
	// SELECT Geometry FROM  table WHERE MbrWithin(Column, BuildMbr(left, bottom, right, top));
	//    or
	// SELECT Geometry,Label FROM  table WHERE MbrWithin(Column, BuildMbr(left, bottom, right, top));
	//
	// where Geometry is the geometry column name and Label is the column containing a name or label.
	std::string label;
	if (getLabel) {
		label = "," + label_col;
	}
	std::stringstream s;
	s <<
		 "SELECT "           <<
		 geometry_col        <<
		 label               <<
		 " FROM "            <<
		 table               <<
		 " WHERE  MbrIntersects(" <<
		 geometry_col        <<
		 ", BuildMbr("         <<
		 left                <<
		 ","                 <<
		 bottom              <<
		 ","                 <<
		 right               <<
		 ","                 <<
		 top                 <<
		 "));";

	// prepare the query
	prepare(s.str());

	// fetch the next result row
	while (step()) {
		// get the geometry
		gaiaGeomCollPtr geom = Geom(0);
		// get the label, if we asked for it
		std::string label;
		if (getLabel) {
			label = Text(1);
		}
		// the following will create lists for points, lines and polygons found in
		// a single geometry. In practice it seems that only one of those types
		// exists for a given geometry, but it's not clear if this is a requirement
		// or just occurs in the sample databases we have been working with.
		PointList points = point_list(geom, label);
		for (PointList::iterator i = points.begin(); i != points.end(); i++) {
			_pointlist.push_back(*i);
		}
		LinestringList lines = linestring_list(geom, label);
		for (LinestringList::iterator i = lines.begin(); i != lines.end(); i++) {
			_linestringlist.push_back(*i);
		}
		PolygonList polys = polygon_list(geom, label);
		for (PolygonList::iterator i = polys.begin(); i != polys.end(); i++) {
			_polygonlist.push_back(*i);
		}
	}

	// finish with this query
	finalize();
}
bool COpenGLStaticMesh::GenerateDisplayListFromMesh(const CStaticMeshBase& staticMesh)
{
	bool							bListGeneratedSuccessfully = false;


	//Obtain a list of polygons from the mesh...
	PolygonList						meshPolyList = staticMesh.GetPolygonList();	

	if (!meshPolyList.empty()) {
		//Number of display lists to generate.
		const QuantityType			kNumDisplayLists = 1;

		//Obtain a display list reference...
		const displayListReference = ::glGenLists(kNumDisplayLists);

		//Create a display list (GL_COMPILE indicates that the list will
		//be created, but not rendered immediately).
		::glNewList(displayListReference, GL_COMPILE);

		// Create texture(s) and bind the texture(s), allowing the texture/
		// textures to be used.
		::glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
		GLuint						textureID;
		::glGenTextures(1, &textureID);

		// Store the texture reference/identifier.
		this->AddTextureLayerReference(textureID);

		::glBindTexture(GL_TEXTURE_2D, textureID);

		::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
		::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
		::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);


		const CTextureCollection&	textureCollection = staticMesh.GetTextureCollection();
		const CBaseTextureData*		pTextureInformation = textureCollection.GetTextureLayer(0);

		if (pTextureInformation) {
			const void*				pRawTextureData = pTextureInformation->GetTextureData();

			if (pRawTextureData) {
				::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, pTextureInformation->GetTextureWidth(),
					pTextureInformation->GetTextureHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, pRawTextureData);
			}

			::glBindTexture(GL_TEXTURE_2D, textureID);
		}

		//Iterate through the list of mesh polygons, adding the polygons
		//to the created OpenGL display list.
		for(PolygonList::iterator polylistIterator = meshPolyList.begin();
			polylistIterator != meshPolyList.end(); polylistIterator++)
		{
			//Obtain the vertex list from the current polygon...
			CFloatPolygon::VertexList	
									vertexList  = polylistIterator->GetVertexList();

			//Create an OpenGl polygon.
			::glBegin(GL_POLYGON);
			for(CFloatPolygon::VertexList::iterator vertexListIterator = vertexList.begin();
				vertexListIterator != vertexList.end(); vertexListIterator++)
			{
				//Set the material properties (basic lighting model interactions -
				//ambient, diffuse, specular, emissive) for the polygon..

				const ScalarType	kMaxSpecularExponent = 128.0;

				//Ambient color.
				CFloatColor			ambientColor =
					polylistIterator->GetLightShading(eShadeAmbient);
				GLfloat				ambientMaterial[] = { ambientColor.GetRedValue(),
					ambientColor.GetGreenValue(), ambientColor.GetBlueValue(), 1.0 };
				glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambientMaterial);

				//Diffuse color.
				CFloatColor			diffuseColor =
					polylistIterator->GetLightShading(eShadeDiffuse);
				GLfloat				diffuseMaterial[] = { diffuseColor.GetRedValue(),
					diffuseColor.GetGreenValue(), diffuseColor.GetBlueValue(), 1.0 };
				glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuseMaterial);

				//Emissive color.
				CFloatColor			emissiveColor =
					polylistIterator->GetLightShading(eShadeEmissive);
				GLfloat				emissiveMaterial[] = { emissiveColor.GetRedValue(),
					emissiveColor.GetGreenValue(), emissiveColor.GetBlueValue(), 1.0 };
				glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emissiveMaterial);			

				//Specular color.
				CFloatColor			specularColor =
					polylistIterator->GetLightShading(eShadeSpecular);
				GLfloat				specularMaterial[] = { specularColor.GetRedValue(), 
					specularColor.GetGreenValue(), specularColor.GetBlueValue(), 1.0 };
				glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specularMaterial);
				glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS,
					kMaxSpecularExponent * polylistIterator->GetSpecularity());
				
				//Retrieve the vertex normal.
				CVector				vertexNormal = vertexListIterator->GetNormal();

				//Store the color/alpha information.
				CFloatColor			vertexColor = vertexListIterator->GetColor();
				::glColor4d(vertexColor.GetRedValue(), vertexColor.GetGreenValue(),
					vertexColor.GetBlueValue(), vertexColor.GetAlphaValue());
				//Store the normal.
				::glNormal3d(vertexNormal.GetXComponent(), vertexNormal.GetYComponent(),
					vertexNormal.GetZComponent());

				//Texture coordinates
				ScalarType			uTextureCoordinate = 0.0;
				ScalarType			vTextureCoordinate = 0.0;
				vertexListIterator->GetTextureCoordinates(uTextureCoordinate, vTextureCoordinate);
				::glTexCoord2f(uTextureCoordinate, vTextureCoordinate);

				//Store the vertex coordinates.
				::glVertex3d(vertexListIterator->GetXCoord(), 
					vertexListIterator->GetYCoord(),
					vertexListIterator->GetZCoord());
			}
			::glEnd();

		#if RENDER_VERTEX_NORMALS
			for(CFloatPolygon::VertexList::iterator vertexNormIterator = vertexList.begin();
				vertexNormIterator != vertexList.end(); vertexNormIterator++)
			{
				//Retrieve the vertex normal.
				CVector				vertexNormal = vertexNormIterator->GetNormal();
				::glBegin(GL_LINES);
				//Render the normal vector (debugging purposes only).
				::glVertex3d(vertexNormIterator->GetXCoord(), 
					vertexNormIterator->GetYCoord(),
					vertexNormIterator->GetZCoord());
				::glVertex3d(vertexNormIterator->GetXCoord() + vertexNormal.GetXComponent(), 
					vertexNormIterator->GetYCoord() + vertexNormal.GetYComponent(),
					vertexNormIterator->GetZCoord() + vertexNormal.GetZComponent());
				::glEnd();
			}
		#endif	//#if RENDER_VERTEX_NORMALS
		}

		// Unbind any texture objects.
		::glBindTexture(GL_TEXTURE_2D, 0);

		//Complete the display list.
		::glEndList();

		//Store the display list reference number.
		this->SetDisplayListReference(displayListReference);

		//Indicate a success condition. 
		bListGeneratedSuccessfully = true;
	}


	//Set the validity flag of the display list reference to
	//correspond to the display list creation result flag.
	this->mbDisplayListReferenceSet = bListGeneratedSuccessfully;

	return(bListGeneratedSuccessfully);
}
int main(int argc, char* argv[])
{
/*
mySF gg;
test(&myF);
test(gg);
*/
    PolygonList plygnList;
    PolygonParser plygnPrsr("polygon.txt");
    if (plygnPrsr.init())
    {
        Polygon tmpPlygn;
        DataTrans tmp(tmpPlygn);
        while (plygnPrsr.hasNext())
        {
            //tmpPlygn.clear();
            tmp.getData().clear();
            plygnPrsr.getPointVec(tmp,tmp);
            plygnList.push_back(tmp.getData());
        }
    }

    VerSegCntnr tmpCntnr;
    STD::vector<VerSegCntnr> segInfoVec;
    GraphLib::IdType invalidId(STD::numeric_limits<int>::max());
    PolygonLinkRec linkRec;
    LinkRecList linkRecList;
    size_t verSegCnt = 0;
    size_t totalVerSegCnt = 0;
    for (STD::list<Polygon>::iterator it=plygnList.begin();
         it != plygnList.end(); ++it )
    {
        assert(0 == (*it).size() % 1 && 4 <= (*it).size() );
        if (!(0==(*it).size() %1 && 4<= (*it).size()) ) continue;
        linkRecList.push_back( STD::make_pair(&(*it), invalidId) );

        verSegCnt = (*it).size() >> 2;
        totalVerSegCnt += verSegCnt;
        tmpCntnr.linkRecPtr_ = &(linkRecList.back());

        //assume the first point is the most lowerleft point
        //O(n) complexity
        //the trap is: itA+=2 could be an action of 2,not as simple as adding.
        Polygon::const_iterator itA = (*it).begin()+1;
        Polygon::const_iterator itB = itA+1; 
        for (;itA != (*it).end() && itB != (*it).end();
              itA+=2,itB+=2)
        {
            tmpCntnr.seg_.head_ = ((*itA).y_<=(*itB).y_) ? (*itA) : (*itB);
            tmpCntnr.seg_.tail_ = ((*itA).y_<=(*itB).y_) ? (*itB) : (*itA);
            printf("PUSH (%d,%d)-(%d,%d)\n", tmpCntnr.seg_.head_.x_,tmpCntnr.seg_.head_.y_,tmpCntnr.seg_.tail_.x_,tmpCntnr.seg_.tail_.y_);
            segInfoVec.push_back(tmpCntnr);
        }
        itB = (*it).begin();
        tmpCntnr.seg_.head_ = ((*itA).y_<=(*itB).y_) ? (*itA) : (*itB);
        tmpCntnr.seg_.tail_ = ((*itA).y_<=(*itB).y_) ? (*itB) : (*itA);
        printf("PUSH (%d,%d)-(%d,%d)\n", tmpCntnr.seg_.head_.x_,tmpCntnr.seg_.head_.y_,tmpCntnr.seg_.tail_.x_,tmpCntnr.seg_.tail_.y_);
        segInfoVec.push_back(tmpCntnr);
    }

    //sort reversely
    STD::sort(segInfoVec.begin(), segInfoVec.end(),sortVerSegByRevX);

    StNodePtrVec treeNodePtrVec(2,static_cast<StNodePtrVec::value_type>(NULL));
    //Collector collector(treeNodePtrVec);
    SegmentTree st; 
    CnstrntGraph graph;
    PolygonLinkRec *leftRecPtr = NULL, *rightRecPtr = NULL, *middleRecPtr = NULL;
    for(size_t idx = 0; idx < segInfoVec.size(); ++idx )
    {
        //collect overlapped datas
        treeNodePtrVec.clear();
        Collector collector(treeNodePtrVec,segInfoVec[idx].linkRecPtr_,segInfoVec[idx].seg_.head_.x_);
        st.getOverlap(segInfoVec[idx].seg_.head_.y_,segInfoVec[idx].seg_.tail_.y_, collector);
        //use the collected datas to build contraints
        if ( treeNodePtrVec[0] || treeNodePtrVec[1] )
        {
            middleRecPtr = segInfoVec[idx].linkRecPtr_;
            if (invalidId == middleRecPtr->second )
                middleRecPtr->second = graph.addNode(Gnode(middleRecPtr));

            printf("Ref:%d %d %d \n", segInfoVec[idx].seg_.head_.y_, segInfoVec[idx].seg_.tail_.y_,segInfoVec[idx].seg_.tail_.x_);
            if (treeNodePtrVec[0])
            {
                printf("left:%d,%d,%d\n", treeNodePtrVec[0]->getStartCoord(), treeNodePtrVec[0]->getEndCoord(), treeNodePtrVec[0]->getRefCoord());         
                leftRecPtr = static_cast<PolygonLinkRec*>(treeNodePtrVec[0]->getId());
                if ( invalidId == leftRecPtr->second )
                    leftRecPtr->second = graph.addNode(Gnode(leftRecPtr));

                SegCoord diff =  segInfoVec[idx].seg_.head_.x_ - treeNodePtrVec[idx]->getRefCoord();
                GraphLib::IdType edgeId;
                //My personal constraint: only one constraint
                if (graph.beginNodeIter(leftRecPtr->second) == graph.endNodeIter(leftRecPtr->second))
                    edgeId = graph.addEdge(leftRecPtr->second, middleRecPtr->second, diff);
                else
                    edgeId = graph.getEdgeId(leftRecPtr->second,middleRecPtr->second);

                if (graph.getEdgeData(edgeId).userData_ > diff) 
                {
                    graph.getEdgeData(edgeId).userData_ = diff;
                }
            }
            if (treeNodePtrVec[1])
            {
                printf("right:%d,%d,%d\n", treeNodePtrVec[1]->getStartCoord(), treeNodePtrVec[1]->getEndCoord(), treeNodePtrVec[1]->getRefCoord());
                rightRecPtr = static_cast<PolygonLinkRec*>(treeNodePtrVec[1]->getId()); 
                if ( invalidId == rightRecPtr->second )
                    rightRecPtr->second = graph.addNode(Gnode(rightRecPtr)); 

                SegCoord diff =  treeNodePtrVec[1]->getRefCoord() - segInfoVec[idx].seg_.head_.x_;
printf("diff:%d\n",diff);
                GraphLib::IdType edgeId;
                //My personal constraint: only one edge
                if (graph.beginNodeIter(middleRecPtr->second) == graph.endNodeIter(middleRecPtr->second))
                    edgeId = graph.addEdge(middleRecPtr->second, rightRecPtr->second, diff);
                else
                    edgeId = graph.getEdgeId(middleRecPtr->second, rightRecPtr->second);

                if (graph.getEdgeData(edgeId).userData_ > diff) 
                {
                    graph.getEdgeData(edgeId).userData_ = diff;
                    graph.getEdgeData(edgeId).toId_ = rightRecPtr->second;
                }
            }
        }

        st.insert_equal( SegmentTreeNode(segInfoVec[idx].seg_.head_.y_, 
                                         segInfoVec[idx].seg_.tail_.y_,
                                         segInfoVec[idx].seg_.head_.x_,
                                         (void*)(segInfoVec[idx].linkRecPtr_)));

        treeNodePtrVec.assign(2,static_cast<StNodePtrVec::value_type>(NULL));
    } 

    printf("NodeCount:%d EdgeCount:%d\n", graph.nodeCount(),graph.edgeCount());
    CnstrntGraph::EdgeIdGen edgeIdGenObj(graph);
    while(edgeIdGenObj.hasNext()) 
    {
        CnstrntGraph::EdgeType& edge = graph.getEdgeData(edgeIdGenObj.getNext());
        CnstrntGraph::NodeType& from = graph.getNodeData(edge.fromId_);
        CnstrntGraph::NodeType& to = graph.getNodeData(edge.toId_);
       
        printf("edge Value:%d shape1:size:%d x:%d, shape2:size:%d x:%d\n",
                edge.userData_, 
                ((Polygon*)(from.userData_.getLinkRecPtr()->first))->size(),
                ((Polygon*)(from.userData_.getLinkRecPtr()->first))->front().x_,
                ((Polygon*)(to.userData_.getLinkRecPtr()->first))->size(),
                ((Polygon*)(to.userData_.getLinkRecPtr()->first))->front().x_
              );
    }

#if 0
// this code snippet is testing that if all the posotion of polygons are all
// altered after the constraint grah is built, this solving system can get
// all the polygons back to where it is such that the constraints are 
// satisfied.
    int shift = 10;
    for (PolygonList::iterator iter = ++plygnList.begin(); iter != plygnList.end(); ++iter)
    {
        for ( Polygon::iterator iter2 = (*iter).begin(); iter2 != (*iter).end(); ++iter2)
        {
            (*iter2).x_ = (*iter2).x_ + shift;
            (*iter2).y_ = (*iter2).y_ + shift;
        }
        shift+=10;
    }
#endif
    //add a fake source
    GraphLib::IdType source = graph.addNode(Gnode(NULL));
    graph.addEdge(source, linkRecList.front().second, 0);

    //longest path
    edgeIdGenObj.init();
    int dist[ graph.nodeCount() ];
    memset(dist,-1,sizeof(dist));
    int parent[graph.nodeCount()];
    dist[source] = 0;
    parent[source] = source;
    for (int count = 0; count < graph.nodeCount(); ++count )
    {
        while (edgeIdGenObj.hasNext())
        {
            CnstrntGraph::EdgeType& edge = graph.getEdgeData(edgeIdGenObj.getNext());
            if ( dist[edge.toId_] < dist[edge.fromId_] + edge.userData_ )
            {
                dist[edge.toId_] = dist[edge.fromId_] + edge.userData_;
                parent[edge.toId_] = edge.fromId_;
            }

        }
        edgeIdGenObj.init();
    }

    edgeIdGenObj.init();
    while (edgeIdGenObj.hasNext())
    {
        CnstrntGraph::EdgeType& edge = graph.getEdgeData(edgeIdGenObj.getNext());
        printf("from:%d dist:%d to:%d dist:%d\n",
                edge.fromId_.val(), dist[edge.fromId_],
                edge.toId_.val(), dist[edge.toId_]
              );
    }

    //for verification
    printf("Start printing result for verification\n");
    dfsPrint(graph,source,dist);    
    printf("End printing result for verification\n");
     
#if 0 
    for (STD::list<Polygon>::const_iterator it=plygnList.begin();
         it != plygnList.end();
         ++it
        )
    {
        for (STD::vector<Point>::const_iterator it2=(*it).begin();
             it2 != (*it).end();
             ++it2
            )
        {
            printf(" (%d %d)-", (*it2).x_, (*it2).y_);
        }
        printf("\n");
    }
#endif
    return EXIT_SUCCESS;
}