polyhedron_ex.h

很多二维 三维几何计算算法 C++ 类库

    double minimum (int coord)
    {
        CGAL_assertion(size_of_vertices() > 0);
        Vertex_iterator pVertex = vertices_begin();
        double minimum = pVertex->point()[coord];
        for(;pVertex != vertices_end();pVertex++)
            minimum = (std::min)(minimum,pVertex->point()[coord]);
        return minimum;
    }
    double maximum (int coord)
    {
        CGAL_assertion(size_of_vertices() > 0);
        Vertex_iterator pVertex = vertices_begin();
        double maximum = pVertex->point()[coord];
        for(;pVertex != vertices_end();pVertex++)
            maximum = (std::max)(maximum,pVertex->point()[coord]);
        return maximum;
    }
    Vertex_handle vertex_min(int coord,
                             double &minimum)
    {
        CGAL_assertion(size_of_vertices() > 0);
        Vertex_iterator pVertex = vertices_begin();
        Vertex_handle pBest = pVertex;
        minimum = pVertex->point()[coord];
        for(;pVertex != vertices_end();pVertex++)
        {
            double value = pVertex->point()[coord];
            if(value < minimum)
            {
                minimum = (std::min)(minimum,value);
                pBest = pVertex;
            }
        }
        return pBest;
    }
    Vertex_handle vertex_max(int coord,
                             double &maximum)
    {
        CGAL_assertion(size_of_vertices() > 0);
        Vertex_iterator pVertex = vertices_begin();
        Vertex_handle pBest = pVertex;
        maximum = pVertex->point()[coord];
        for(;pVertex != vertices_end();pVertex++)
        {
            double value = pVertex->point()[coord];
            if(value > maximum)
            {
                maximum = (std::max)(maximum,value);
                pBest = pVertex;
            }
        }
        return pBest;
    }

    // Index all mesh vertices following the order of the vertices_begin() iterator
    void precompute_vertex_indices()
    {
        Vertex_iterator pVertex;
        unsigned int i = 0;
        for(pVertex = vertices_begin();
            pVertex != vertices_end();
            pVertex++)
            pVertex->index(i++);
    }

    // Index all mesh half edges following the order of the halfedges_begin() iterator
    void precompute_halfedge_indices()
    {
        Halfedge_iterator pHalfedge;
        unsigned int i = 0;
        for(pHalfedge = halfedges_begin();
            pHalfedge != halfedges_end();
            pHalfedge++)
        pHalfedge->index(i++);
    }


#ifdef DEBUG_TRUNCATE_OUTPUT
    // Debug: write coordinates with 2 digits precision
    #define FORMAT_EPS_COORD(x) (int(x/10.0+0.5)*10)
#else
    #define FORMAT_EPS_COORD(x) (x)
#endif
            
    // Dump parameterized mesh to an eps file
    bool write_file_eps(const char *pFilename,
                        double scale = 500.0)
    {
        assert(pFilename != NULL);

        std::ofstream out(pFilename);
        if(!out)
            return false;
        CGAL::set_ascii_mode(out);

        // compute bounding box
        double xmin,xmax,ymin,ymax;
        xmin = ymin = xmax = ymax = 0;
        Halfedge_iterator pHalfedge;
        for(pHalfedge = halfedges_begin();
            pHalfedge != halfedges_end();
            pHalfedge++)
        {
            double x1 = scale * pHalfedge->prev()->u();
            double y1 = scale * pHalfedge->prev()->v();
            double x2 = scale * pHalfedge->u();
            double y2 = scale * pHalfedge->v();
            xmin = (std::min)(xmin,x1);
            xmin = (std::min)(xmin,x2);
            xmax = (std::max)(xmax,x1);
            xmax = (std::max)(xmax,x2);
            ymax = (std::max)(ymax,y1);
            ymax = (std::max)(ymax,y2);
            ymin = (std::min)(ymin,y1);
            ymin = (std::min)(ymin,y2);
        }

        out << "%!PS-Adobe-2.0 EPSF-2.0" << std::endl;
        out << "%%BoundingBox: " << int(xmin+0.5) << " "
                                 << int(ymin+0.5) << " "
                                 << int(xmax+0.5) << " "
                                 << int(ymax+0.5) << std::endl;
        out << "%%HiResBoundingBox: " << xmin << " "
                                      << ymin << " "
                                      << xmax << " "
                                      << ymax << std::endl;
        out << "%%EndComments" << std::endl;
        out << "gsave" << std::endl;
        out << "0.1 setlinewidth" << std::endl;

        // color macros
        out << std::endl;
        out << "% RGB color command - r g b C" << std::endl;
        out << "/C { setrgbcolor } bind def" << std::endl;
        out << "/white { 1 1 1 C } bind def" << std::endl;
        out << "/black { 0 0 0 C } bind def" << std::endl;

        // edge macro -> E
        out << std::endl;
        out << "% Black stroke - x1 y1 x2 y2 E" << std::endl;
        out << "/E {moveto lineto stroke} bind def" << std::endl;
        out << "black" << std::endl << std::endl;

        // output edge coordinates
        for(pHalfedge = halfedges_begin();
            pHalfedge != halfedges_end();
            pHalfedge++)
        {
            double x1 = scale * pHalfedge->prev()->u();
            double y1 = scale * pHalfedge->prev()->v();
            double x2 = scale * pHalfedge->u();
            double y2 = scale * pHalfedge->v();
            out << FORMAT_EPS_COORD(x1) << " " 
                << FORMAT_EPS_COORD(y1) << " " 
                << FORMAT_EPS_COORD(x2) << " " 
                << FORMAT_EPS_COORD(y2) << " E" << std::endl;
        }
            
        /* Emit EPS trailer. */
        out << "grestore" << std::endl;
        out << std::endl;
        out << "showpage" << std::endl;

        return true;
    }

#ifdef DEBUG_TRUNCATE_OUTPUT
    // Debug: write coordinates with 2 digits precision
    #define FORMAT_UV(x) (float(int(x*100.0+0.5))/100.0)
#else
    #define FORMAT_UV(x) (x)
#endif
            
    // Dump parameterized mesh to a Wavefront OBJ file
    // v x y z
    // f 1 2 3 4 (1-based)
    //
    // Implementation note: the UV is meaningless for a NON parameterized halfedge
    bool write_file_obj(const char *pFilename)
    {
        assert(pFilename != NULL);

        std::ofstream out(pFilename);
        if(!out)
            return false;
        CGAL::set_ascii_mode(out);

        // Index all mesh vertices following the order of vertices_begin() iterator
        precompute_vertex_indices();
        // Index all mesh half edges following the order of halfedges_begin() iterator
        precompute_halfedge_indices();

        // write the name of material file
        out <<  "mtllib parameterization.mtl" << std::endl ;

        // output coordinates
        out <<  "# vertices" << std::endl ;
        Vertex_iterator pVertex;
        for(pVertex = vertices_begin(); pVertex != vertices_end(); pVertex++)
            out << "v " << pVertex->point().x() << " "
                        << pVertex->point().y() << " "
                        << pVertex->point().z() << std::endl;

        // Write UVs (1 UV / halfedge)
        out <<  "# uv coordinates" << std::endl ;
        Halfedge_iterator pHalfedge;
        for(pHalfedge = halfedges_begin(); pHalfedge != halfedges_end(); pHalfedge++)
        {
            if (pHalfedge->is_parameterized())
                out << "vt " << FORMAT_UV(pHalfedge->u()) << " " << FORMAT_UV(pHalfedge->v()) << std::endl;
            else
                out << "vt " << 0.0 << " " << 0.0 << std::endl;
        }
            
        // Write facets using the unique material # 1
        out << "# facets" << std::endl;
        out << "usemtl Mat_1" << std::endl;
        Facet_const_iterator pFacet;
        for(pFacet = facets_begin(); pFacet != facets_end(); pFacet++)
        {
            Halfedge_around_facet_const_circulator h = pFacet->facet_begin();
            out << "f";
            do {
                out << " " << h->vertex()->index()+1;
                if (h->is_parameterized())
                    out <<  "/" << h->index()+1;
            }
            while(++h != pFacet->facet_begin());
            out << std::endl;
        }

        return true;
    }

    // is vertex on border ?
    static bool is_border(Vertex_const_handle pVertex)
    {
        Halfedge_around_vertex_const_circulator pHalfedge = pVertex->vertex_begin();
        Halfedge_around_vertex_const_circulator end = pHalfedge;
        if(pHalfedge == NULL) // isolated vertex
            return true;
        CGAL_For_all(pHalfedge,end)
            if(pHalfedge->is_border())
            return true;
        return false;
    }

    // compute distance from facet center to halfedge center
    double distance(Facet_handle pFacet,
                    Halfedge_handle pHalfedge)
    {
        // we assume
        Point_3 center_facet = pFacet->center();

        Vector_3 v = (pHalfedge->opposite()->vertex()->point()
                 - pHalfedge->vertex()->point());
        Point_3 center_halfedge = pHalfedge->vertex()->point() + (v/2);
        Vector_3 d = center_facet-center_halfedge;
        return std::sqrt(d*d);
    }

    void farthest_point_aligned(Vertex_handle &pVertexMin,
                                Vertex_handle &pVertexMax)
    {
        double xmin,xmax,ymin,ymax,zmin,zmax;
        Vertex_handle pVertex_xMin = vertex_min(0,xmin);
        Vertex_handle pVertex_xMax = vertex_max(0,xmax);
        Vertex_handle pVertex_yMin = vertex_min(1,ymin);
        Vertex_handle pVertex_yMax = vertex_max(1,ymax);
        Vertex_handle pVertex_zMin = vertex_min(2,zmin);
        Vertex_handle pVertex_zMax = vertex_max(2,zmax);
        double xdiff = xmax-xmin;
        double ydiff = ymax-ymin;
        double zdiff = zmax-zmin;
        if (xdiff >= (std::max)(ydiff,zdiff))
        {
            pVertexMin = pVertex_xMin;
            pVertexMax = pVertex_xMax;
        }
        else if (ydiff >= (std::max)(xdiff,zdiff))
        {
            pVertexMin = pVertex_yMin;
            pVertexMax = pVertex_yMax;
        }
        else
        {
            pVertexMin = pVertex_zMin;
            pVertexMax = pVertex_zMax;
        }
    }

}; // end class PolyhedronEx


#endif // POLYHEDRON_EX_H_INCLUDED