511 lines
15 KiB
C++
511 lines
15 KiB
C++
/****************************************************************************
|
|
* VCGLib o o *
|
|
* Visual and Computer Graphics Library o o *
|
|
* _ O _ *
|
|
* Copyright(C) 2006 \/)\/ *
|
|
* Visual Computing Lab /\/| *
|
|
* ISTI - Italian National Research Council | *
|
|
* \ *
|
|
* All rights reserved. *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
* This program is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
|
|
* for more details. *
|
|
* *
|
|
****************************************************************************/
|
|
/****************************************************************************
|
|
History
|
|
|
|
$Log: not supported by cvs2svn $
|
|
Revision 1.10 2007/07/10 07:48:41 cignoni
|
|
changed a template >> into > >
|
|
|
|
Revision 1.9 2007/07/10 06:58:31 cignoni
|
|
added a missing typename
|
|
|
|
Revision 1.8 2007/07/09 15:36:40 andrenucci
|
|
fix bug with exporting of translate plans
|
|
|
|
Revision 1.7 2007/06/13 09:17:14 andrenucci
|
|
Fix problem with scale
|
|
|
|
Revision 1.5 2007/05/29 10:09:29 cignoni
|
|
Added a const (and reformatted)
|
|
|
|
Revision 1.4 2007/05/21 13:22:40 cignoni
|
|
Corrected gcc compiling issues
|
|
|
|
Revision 1.3 2006/02/16 15:16:51 corsini
|
|
Add reference plane support
|
|
|
|
Revision 1.2 2006/02/15 15:40:06 corsini
|
|
Decouple SVG properties and exporter for simmetry with the other exporter
|
|
|
|
Revision 1.1 2006/02/13 16:18:09 corsini
|
|
first working version
|
|
|
|
|
|
****************************************************************************/
|
|
#ifndef __VCG_LIB_EXPORTER_SVG
|
|
#define __VCG_LIB_EXPORTER_SVG
|
|
|
|
namespace vcg
|
|
{
|
|
namespace edge
|
|
{
|
|
namespace io
|
|
{
|
|
|
|
/**
|
|
* SVG Properties.
|
|
*
|
|
* Support class to set the properties of the SVG exporter.
|
|
*/
|
|
class SVGProperties
|
|
{
|
|
// definitions
|
|
public:
|
|
|
|
//! Stroke colors.
|
|
enum StrokeColor
|
|
{
|
|
BLACK, SILVER, GRAY, WHITE,
|
|
MAROON, RED, PURPLE, FUCHSIA,
|
|
GREEN, LIME, OLIVE, YELLOW,
|
|
NAVY, BLUE, TEAL, AQUA
|
|
};
|
|
|
|
//! Stroke linecap types.
|
|
enum StrokeLineCap
|
|
{
|
|
BUTT, ROUND, SQUARE
|
|
};
|
|
|
|
static const int DEFAULT_LINE_WIDTH=2;
|
|
|
|
//in single-file export make the grid of sessiones
|
|
int numCol;
|
|
int numRow;
|
|
|
|
|
|
// private data members
|
|
private:
|
|
|
|
// Line width.
|
|
int lwidth;
|
|
|
|
// Stroke color (see StrokeColor).
|
|
std::string stroke_color;
|
|
|
|
// Stroke linecap (see StrokeLineCap).
|
|
std::string stroke_linecap;
|
|
|
|
// Plane where to project the edge mesh.
|
|
Plane3d proj;
|
|
|
|
// Scale of rdrawing respect coordinates of mesh
|
|
float scale;
|
|
|
|
// Dimension of the drawing square
|
|
Point2d ViewBox;
|
|
|
|
int width,height; //Express in cm
|
|
|
|
// Position of the drawing square
|
|
Point2d position;
|
|
|
|
//Text details
|
|
bool showDetails;
|
|
|
|
//Starting offset
|
|
float Xmin, Ymin;
|
|
Point2f* minPos;
|
|
Point2f* maxPos;
|
|
|
|
|
|
|
|
// construction
|
|
public:
|
|
|
|
SVGProperties()
|
|
{
|
|
lwidth = DEFAULT_LINE_WIDTH;
|
|
|
|
const char * DEFAULT_LINE_COLOR = "black";
|
|
const char * DEFAULT_LINE_CAP= "round";
|
|
|
|
stroke_color = DEFAULT_LINE_COLOR;
|
|
stroke_linecap = DEFAULT_LINE_CAP;
|
|
|
|
// default projection plane (XZ plane)
|
|
Point3d n(0.0, 1.0, 0.0);
|
|
proj.SetDirection(n);
|
|
proj.SetOffset(0.0);
|
|
|
|
scale=0; //scale=0 it means expanded to the boards of the canvas
|
|
ViewBox=Point2d(1000, 1000);
|
|
position=Point2d(0, 0);
|
|
width=10; //width of the windows
|
|
height=10; //height of the windows
|
|
showDetails=true;
|
|
Xmin=0;
|
|
Ymin=0;
|
|
minPos= new Point2f(0,0);
|
|
maxPos= new Point2f(0,0);
|
|
}
|
|
|
|
// public methods
|
|
public:
|
|
|
|
//! Set the line width.
|
|
void setLineWidth(int width)
|
|
{
|
|
lwidth = width;
|
|
}
|
|
|
|
//! Set the stroke color.
|
|
void setColor(enum StrokeColor color)
|
|
{
|
|
switch (color)
|
|
{
|
|
case BLACK : stroke_color = "black"; break;
|
|
case SILVER : stroke_color = "silver"; break;
|
|
case GRAY : stroke_color = "gray"; break;
|
|
case WHITE : stroke_color = "white"; break;
|
|
case MAROON : stroke_color = "maroon"; break;
|
|
case RED : stroke_color = "red"; break;
|
|
case PURPLE : stroke_color = "purple"; break;
|
|
case FUCHSIA: stroke_color = "fuchsia"; break;
|
|
case GREEN : stroke_color = "green"; break;
|
|
case OLIVE : stroke_color = "olive"; break;
|
|
case LIME : stroke_color = "lime"; break;
|
|
case NAVY : stroke_color = "navy"; break;
|
|
case TEAL : stroke_color = "teal"; break;
|
|
case AQUA : stroke_color = "aqua"; break;
|
|
default: assert(0);
|
|
}
|
|
}
|
|
|
|
//! Set the line cap style.
|
|
void setLineCap(enum StrokeLineCap linecap)
|
|
{
|
|
if (linecap == BUTT) stroke_linecap = "butt";
|
|
else if (linecap == ROUND) stroke_linecap = "round";
|
|
else if (linecap == SQUARE) stroke_linecap = "square";
|
|
}
|
|
|
|
void setPlane(double distance, const Point3d &direction)
|
|
{
|
|
proj.SetDirection(direction);
|
|
proj.SetOffset(distance);
|
|
}
|
|
|
|
void setScale(float x){ scale=x; } //Define the scale between 2d coordinate and mesh
|
|
|
|
void setViewBox(Point2d x) { ViewBox=x; }//Define the dimension of the square
|
|
|
|
void setPosition(Point2d x) { position=x;}//Define the starting position of the canvas
|
|
void setTextDetails(bool x){showDetails=x;}
|
|
void setDimension(int width, int height){ this->width=width; this->height=height;}
|
|
|
|
// accessors
|
|
public:
|
|
|
|
int lineWidth(){return lwidth;}
|
|
const char * lineColor(){return stroke_color.c_str();}
|
|
const char * lineCapStyle(){return stroke_linecap.c_str();}
|
|
const Plane3d * projPlane(){return &proj;}
|
|
float getScale(){return scale;}
|
|
Point2d getViewBox(){return ViewBox;}
|
|
Point2d getPosition(){return position;}
|
|
|
|
int getWidth(){return width;}
|
|
bool showTextDetails(){return showDetails;}
|
|
int getHeight(){return height;}
|
|
|
|
void setMinPoint(Point2f* p){
|
|
minPos = p;
|
|
}
|
|
void setMaxPoint(Point2f* p){
|
|
maxPos = p;
|
|
}
|
|
Point2f* getminPoint(){return (minPos);}
|
|
Point2f* getmaxPoint(){return (maxPos);}
|
|
|
|
|
|
};
|
|
|
|
|
|
/**
|
|
* SVG exporter.
|
|
*
|
|
* This exporter save a mesh of EdgeMesh type in the SVG format.
|
|
* Most of the features of the SVG format are not supported.
|
|
* The given EdgeMesh is saved as a set lines. The properties
|
|
* of the SVG export can be set through the SVGProp class.
|
|
*/
|
|
template <class EdgeMeshType>
|
|
class ExporterSVG
|
|
{
|
|
|
|
public:
|
|
|
|
//! Save with the default SVG properties.
|
|
static bool Save(EdgeMeshType *mp, const char *filename)
|
|
{
|
|
SVGProperties properties;
|
|
return Save(mp, filename, properties);
|
|
}
|
|
static bool Save(vector<EdgeMeshType*> *vp, const char *filename, SVGProperties & pro){
|
|
//Function that export a vector of EdgeMesh in an unic single SVG file.
|
|
FILE * o = fopen(filename,"w");
|
|
if (o==NULL)
|
|
return false;
|
|
int num = (*vp).size(); //number of square to draw
|
|
WriteXmlHead(o,pro.getWidth(),pro.getHeight(),pro.getViewBox(),Point2d(0,0));
|
|
float scale= pro.getScale();
|
|
typename std::vector<EdgeMeshType*>::iterator it;
|
|
int i=0;
|
|
Point2f pmin(100000000.0f, 100000000.0f);
|
|
Point2f pmax(-10000000.0f, -10000000.0f);
|
|
for(it=(*vp).begin(); it!=(*vp).end(); it++){
|
|
EdgeMeshType* ed;
|
|
ed=(*it);
|
|
Save(ed,o,pro, -2);
|
|
Point2f* pmi=pro.getminPoint();
|
|
Point2f* pma=pro.getmaxPoint();
|
|
pmin[0]=min(pmin[0], pmi->X());
|
|
pmin[1]=min(pmin[1], pmi->Y());
|
|
pmax[0]=max(pmax[0], pma->X());
|
|
pmax[1]=max(pmax[1], pma->Y());
|
|
}
|
|
float maxEdge=max(pmax[0]-pmin[0], pmax[1]-pmin[1]);
|
|
float scl = (pro.getViewBox().V(0)/pro.numCol) /maxEdge ;
|
|
pro.setScale(scl);
|
|
pro.setMinPoint(new Point2f(pmin[0],pmin[1]));
|
|
pro.setMaxPoint(new Point2f(pmax[0],pmax[1]));
|
|
for(it=(*vp).begin(); it!=(*vp).end(); it++){
|
|
|
|
EdgeMeshType* ed;
|
|
ed=(*it);
|
|
|
|
pro.setPosition(Point2d((pro.getViewBox().V(0)/pro.numCol)*i,40));
|
|
|
|
int x=pro.getViewBox().V(0);
|
|
int y=pro.getViewBox().V(1);
|
|
/*
|
|
fprintf(o, "<rect width= \" %d \" height= \" %d \" x=\"%d \" y=\" %d \" style= \" stroke-width:1; fill-opacity:0.0; stroke:rgb(0,0,0)\" /> \n",x/pro.numCol,y, (x/pro.numCol)*i, 40);
|
|
*/
|
|
Save(ed,o,pro, i);
|
|
|
|
if(pro.showTextDetails()){
|
|
fprintf(o,"<text x= \" %d \" y= \"30 \" font-family= \"Verdana \" font-size= \"30 \" >\n",(x/pro.numCol)*i);
|
|
fprintf(o,"Slice num:%d </text>\n", i);}
|
|
i++;
|
|
}
|
|
fprintf(o, "</svg>");
|
|
fclose(o);
|
|
return true;
|
|
}
|
|
//! Save with the given SVG properties.
|
|
static bool Save(EdgeMeshType *mp, const char *filename, SVGProperties & props )
|
|
{
|
|
|
|
FILE * o = fopen(filename,"w");
|
|
if (o==NULL)
|
|
return false;
|
|
|
|
WriteXmlHead(o, props.getWidth(),props.getHeight(), props.getViewBox(), props.getPosition());
|
|
|
|
props.setPosition(Point2d(0,40));
|
|
Save(mp, o, props, -1);
|
|
fprintf(o, "</svg>");
|
|
|
|
|
|
// final xml tags
|
|
|
|
fclose(o);
|
|
return true;
|
|
}
|
|
|
|
static void Save(EdgeMeshType *mp, FILE* o, SVGProperties props, int numSlice)
|
|
{
|
|
bool preCal=false;
|
|
|
|
if(numSlice==-2) preCal=true;
|
|
// build vector basis (n, v1, v2)
|
|
Point3d p1(0.0,0.0,0.0);
|
|
Point3d p2(1.0,0.0,0.0);
|
|
Point3d p2less(-1.0,0.0,0.0);
|
|
Point3d d = props.projPlane()->Direction() - p2;
|
|
Point3d dless = props.projPlane()->Direction() - p2less;
|
|
Point3d v1;
|
|
if ((d.Norm() < 0.5)||(dless.Norm() <0.5))
|
|
v1 = Point3d(0.0,0.0,1.0) - p1;
|
|
else
|
|
v1 = p2 - p1;
|
|
|
|
v1.Normalize();
|
|
Point3d v2 = v1 ^ props.projPlane()->Direction();
|
|
//Global points
|
|
vector<vector<Point2f> >* glb;
|
|
std::vector<Point2f> pts;
|
|
pts.clear();
|
|
Point2f pmin(100000000.0f, 100000000.0f);
|
|
Point2f pmax(-100000000.0f, -100000000.0f);
|
|
Point3d bbMin;
|
|
|
|
typename EdgeMeshType::EdgeIterator i;
|
|
|
|
for (i = mp->edges.begin(); i != mp->edges.end(); ++i)
|
|
{
|
|
Point3<typename EdgeMeshType::ScalarType> p1;
|
|
Point3<typename EdgeMeshType::ScalarType> p2;
|
|
|
|
p1 = (*i).V(0)->P();
|
|
p2 = (*i).V(1)->P();
|
|
|
|
|
|
|
|
Point3d p1d(p1[0], p1[1], p1[2]);
|
|
Point3d p2d(p2[0], p2[1], p2[2]);
|
|
|
|
|
|
// Project the line on the reference plane
|
|
|
|
Point3d p1proj = props.projPlane()->Projection(p1d);
|
|
Point3d p2proj = props.projPlane()->Projection(p2d);
|
|
|
|
|
|
// Convert the 3D coordinates of the line to the uv coordinates of the plane
|
|
Point2f pt1(static_cast<float>(p1proj * v1), static_cast<float>(p1proj * v2));
|
|
Point2f pt2(static_cast<float>(p2proj * v1), static_cast<float>(p2proj * v2));
|
|
|
|
pts.push_back(pt1);
|
|
pts.push_back(pt2);
|
|
|
|
pmin[0]=math::Min(math::Min(pt1[0],pmin[0]), pt2[0]);
|
|
pmin[1]=math::Min(math::Min(pt1[1],pmin[1]), pt2[1]);
|
|
pmax[0]=math::Max(math::Max(pt1[0],pmax[0]), pt2[0]);
|
|
pmax[1]=math::Max(math::Max(pt1[1],pmax[1]), pt2[1]);
|
|
|
|
|
|
}
|
|
|
|
//Point2f bbp(static_cast<float>(bbMin * v1), static_cast<float>(bbMin * v2));
|
|
if(!preCal){
|
|
float scale=props.getScale();
|
|
|
|
// line settings
|
|
Point2d pos=props.getPosition();
|
|
|
|
fprintf(o, " <g stroke=\"%s\" stroke-linecap=\"%s\" > \n",
|
|
props.lineColor(), props.lineCapStyle());
|
|
float maxEdges= math::Max((pmax[0]-pmin[0]), (pmax[1]-pmin[1]));
|
|
if (numSlice==0)
|
|
Draw_proportions_scale(o,maxEdges, props);
|
|
fprintf(o, "<svg id = \" %d \">\n", numSlice );
|
|
int x=props.getViewBox().V(0);
|
|
int y=props.getViewBox().V(1);
|
|
if(numSlice>=0)
|
|
fprintf(o, "<rect width= \" %d \" height= \" %d \" x=\"%d \" y=\" %d \" style= \" stroke-width:1; fill-opacity:0.0; stroke:rgb(0,0,0)\" /> \n",x/props.numCol,y, (x/props.numCol)*numSlice, 40);
|
|
else
|
|
fprintf(o, "<rect width= \" %d \" height= \" %d \" x=\"%d \" y=\" %d \" style= \" stroke-width:1; fill-opacity:0.0; stroke:rgb(0,0,0)\" /> \n",x/props.numCol,y, 0, 40);
|
|
|
|
|
|
std::vector<Point2f>::iterator itPoints;
|
|
for(itPoints = pts.begin(); itPoints != pts.end(); ++itPoints)
|
|
{
|
|
Point2f p1 = *itPoints;
|
|
++itPoints;
|
|
Point2f p2 = *itPoints;
|
|
if(numSlice==-1){
|
|
fprintf(o, " <line x1=\"%f\" y1=\"%f\" x2=\"%f\" y2=\"%f\" \n",
|
|
pos.X()+((p1[0]-pmin[0]) * scale), pos.Y()+((p1[1]-pmin[1]) * scale),
|
|
pos.X()+((p2[0]-pmin[0]) * scale), pos.Y()+((p2[1]-pmin[1]) * scale ));
|
|
fprintf(o, " stroke-width = \"%d\" ",props.lineWidth());
|
|
fprintf(o, "/>\n");
|
|
}
|
|
else{
|
|
fprintf(o, " <line x1=\"%f\" y1=\"%f\" x2=\"%f\" y2=\"%f\" \n",
|
|
pos.X()+((p1[0]-props.getminPoint()->X()) * scale), pos.Y()+((p1[1]-props.getminPoint()->Y()) * scale),
|
|
pos.X()+((p2[0]-props.getminPoint()->X()) * scale), pos.Y()+((p2[1]-props.getminPoint()->Y()) * scale ));
|
|
fprintf(o, " stroke-width = \"%d\" ",props.lineWidth());
|
|
fprintf(o, "/>\n");}
|
|
}
|
|
fprintf(o, "</svg>");
|
|
fprintf(o, " </g>\n");
|
|
}
|
|
else{
|
|
Point2f* pmi=props.getminPoint();
|
|
Point2f* pma=props.getmaxPoint();
|
|
pmi->X()=pmin[0];
|
|
pmi->Y()=pmin[1];
|
|
pma->X()=pmax[0];
|
|
pma->Y()=pmax[1];
|
|
props.setMinPoint(pmi);
|
|
props.setMaxPoint(pma);
|
|
|
|
}
|
|
}
|
|
|
|
private:
|
|
|
|
static void Draw_proportions_scale(FILE *o, float maxEdge,SVGProperties & prop){
|
|
if(prop.showTextDetails()){
|
|
int num_order=log10(maxEdge);
|
|
int pox= pow(10.0, num_order);
|
|
int assX=prop.getViewBox()[0];
|
|
int assY=prop.getViewBox()[1];
|
|
int nullAss=0;
|
|
int OffsetXAs=50;
|
|
float comput= OffsetXAs+(pox*prop.getScale());
|
|
fprintf(o, " <line x1=\" %d \" y1=\" %d \" x2=\" %f \" y2=\" %d \" \n",(nullAss+OffsetXAs ),(assY+50),comput, (assY+50) );
|
|
fprintf(o, " stroke-width = \"5\" ");
|
|
fprintf(o, "/>\n");
|
|
fprintf(o,"<text x= \" %d \" y= \" %d \" font-family= \"Verdana \" font-size= \"25 \" >",(nullAss+OffsetXAs), (assY+80));
|
|
|
|
|
|
fprintf(o,"%d px -- Scale %f : 1 </text>", pox ,prop.getScale());
|
|
}
|
|
}
|
|
static void WriteXmlHead(FILE *o,int width, int height, Point2d viewBox, Point2d position){
|
|
|
|
int Vx=viewBox[0];
|
|
int Vy=viewBox[1];
|
|
// initial xml tags
|
|
fprintf(o, "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n");
|
|
fprintf(o, "<!-- Created with vcg library -->\n");
|
|
fprintf(o, "<svg width=\"%d cm\" height=\"%d cm\" viewBox=\"0 0 %d %d \" \n",width, height, Vx, Vy+100);
|
|
fprintf(o, " xmlns:dc=\"http://purl.org/dc/elements/1.1/\" \n");
|
|
fprintf(o, " xmlns:cc=\"http://web.resource.org/cc/\" \n");
|
|
fprintf(o, " xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\" \n");
|
|
fprintf(o, " xmlns:svg=\"http://www.w3.org/2000/svg\" \n");
|
|
fprintf(o, " xmlns=\"http://www.w3.org/2000/svg\" \n");
|
|
fprintf(o, " id=\"svg2\"> \n");
|
|
fprintf(o, " <defs id=\"defs4\"/> \n");
|
|
fprintf(o, " <metadata id=\"metadata7\"> \n");
|
|
fprintf(o, " <rdf:RDF> \n");
|
|
fprintf(o, " <cc:Work rdf:about=\"\"> \n");
|
|
fprintf(o, " <dc:format>image/svg+xml</dc:format> \n");
|
|
fprintf(o, " <dc:type rdf:resource=\"http://purl.org/dc/dcmitype/StillImage\" /> \n");
|
|
fprintf(o, " </cc:Work> \n");
|
|
fprintf(o, " </rdf:RDF> \n");
|
|
fprintf(o, " </metadata> \n");
|
|
}
|
|
|
|
};
|
|
|
|
|
|
}; // namespace io
|
|
}; // namespace edge
|
|
}; // namespace vcg
|
|
#endif // __VCG_LIB_EXPORTER_SVG
|