216 lines
7.6 KiB
C++
216 lines
7.6 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. *
|
|
* *
|
|
****************************************************************************/
|
|
|
|
#ifndef __VCG_LIB_EXPORTER_SVG
|
|
#define __VCG_LIB_EXPORTER_SVG
|
|
|
|
namespace vcg
|
|
{
|
|
namespace edg
|
|
{
|
|
namespace io
|
|
{
|
|
|
|
/**
|
|
* SVG Properties.
|
|
*
|
|
* Support class to set the properties of the SVG exporter.
|
|
*/
|
|
class SVGProperties
|
|
{
|
|
// definitions
|
|
public:
|
|
|
|
// When multiple meshes are passed, they are arranged in a grid according these two values.
|
|
// the default is two column and enough row. If numRow is not sufficient it is automatically enlarged.
|
|
int numCol;
|
|
int numRow;
|
|
|
|
Point2f sizeCm; // The size, in the drawing, of each ViewBox (in cm)
|
|
|
|
Point2f marginCm; // how much space between each slice box (in cm)
|
|
|
|
Point2f pageSizeCm() // This is automatically computed from the above values
|
|
{
|
|
float xSize = numCol*sizeCm[0] + numCol*marginCm[0] + marginCm[0];
|
|
float ySize = numRow*sizeCm[1] + numRow*marginCm[1] + marginCm[1];
|
|
return Point2f(xSize,ySize);
|
|
}
|
|
|
|
|
|
Point3f projDir; // Direction of the Projection
|
|
Point3f projUp;
|
|
Point3f projCenter; // the 3d point that after projection will fall exactly in the center of the ViewBox.
|
|
|
|
// How the mesh will be scaled.
|
|
// if this value is 0 the bounding box of all the passed meshes will be used to compute the scale and center
|
|
// otherwise it is a scaling factor that is used to place the mesh in a unit cube (-1..1)
|
|
// usually it is 2/bbox.Diag
|
|
float scale;
|
|
|
|
// SVG Style Parameters
|
|
int lineWidthPt; // Line width.
|
|
std::string strokeColor; // Stroke color (see StrokeColor).
|
|
std::string strokeLineCap;// Stroke linecap (see StrokeLineCap).
|
|
|
|
//Text details
|
|
bool showTextDetails;
|
|
|
|
public:
|
|
|
|
SVGProperties()
|
|
{
|
|
lineWidthPt = 1;
|
|
strokeColor = "black";
|
|
strokeLineCap = "round";
|
|
|
|
// default projection (XZ plane with the z up)
|
|
projDir= Point3f(0.0, 1.0, 0.0);
|
|
projUp = Point3f(0.0, 0.0, 1.0);
|
|
scale=0;
|
|
//viewBox=Point2f(10, 10);
|
|
projCenter=Point3f(0, 0, 0);
|
|
sizeCm=Point2f(10,10);
|
|
marginCm=Point2f(1,1);
|
|
showTextDetails=true;
|
|
numCol=2;
|
|
numRow=10;
|
|
}
|
|
|
|
};
|
|
|
|
|
|
/**
|
|
* 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:
|
|
|
|
// Standard saving Function
|
|
// just a wrapper to the below
|
|
static bool Save(EdgeMeshType &m, const char *filename, SVGProperties & pro)
|
|
{
|
|
std::vector<EdgeMeshType*> MeshVec;
|
|
MeshVec.push_back(&m);
|
|
return Save(MeshVec,filename,pro);
|
|
}
|
|
|
|
|
|
// Main saving function
|
|
// save a Multiple Set of Edge Meshes on a single SVG files
|
|
static bool Save(std::vector<EdgeMeshType*> &meshVec, const char *filename, SVGProperties & pro)
|
|
{
|
|
FILE * fpo = fopen(filename,"w");
|
|
if (fpo==NULL) return false;
|
|
|
|
WriteXmlHead(fpo, pro);
|
|
for(int i=0;i<meshVec.size();++i)
|
|
{
|
|
WriteXmlBody(fpo, *meshVec[i], pro, i );
|
|
}
|
|
fprintf(fpo, "</svg>");
|
|
fclose(fpo);
|
|
return true;
|
|
}
|
|
|
|
|
|
static void WriteXmlHead(FILE *o, SVGProperties & pro)
|
|
{
|
|
fprintf(o, "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n");
|
|
fprintf(o, "<!-- Created with vcg library -->\n");
|
|
fprintf(o, "<svg width=\"%fcm\" height=\"%fcm\" \n",pro.pageSizeCm()[0], pro.pageSizeCm()[1]);
|
|
fprintf(o, " xmlns=\"http://www.w3.org/2000/svg\" \n");
|
|
fprintf(o, " xmlns:xlink=\"http://www.w3.org/1999/xlink\" \n");
|
|
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 \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 \n");
|
|
}
|
|
|
|
static void WriteXmlBody(FILE* fpo, EdgeMeshType &mp, SVGProperties &pro, int meshIndex)
|
|
{
|
|
int rowInd = meshIndex / pro.numCol;
|
|
int colInd = meshIndex % pro.numCol;
|
|
|
|
fprintf(fpo, " <rect width= \" %fcm \" height= \" %fcm \" x=\"%fcm \" y=\"%fcm \" "
|
|
" style= \" stroke-width:1pt; fill-opacity:0.0; stroke:rgb(0,0,0)\" /> \n",
|
|
pro.sizeCm[0], pro.sizeCm[1], pro.marginCm[0]+colInd*(pro.sizeCm[0]+pro.marginCm[0]), pro.marginCm[1]+rowInd*(pro.sizeCm[1]+pro.marginCm[1]));
|
|
fprintf(fpo, "<g stroke=\"%s\" stroke-linecap=\"%s\" stroke-width = \"%fpt\" > \n", pro.strokeColor.c_str(), pro.strokeLineCap.c_str(),pro.lineWidthPt/100.0f);
|
|
fprintf(fpo, " <svg id = \"SliceNum%d\" viewBox=\"-1000 -1000 2000 2000\" width=\"%fcm\" height=\"%fcm\" x=\"%fcm\" y=\"%fcm\" >\n", meshIndex,pro.sizeCm[0],pro.sizeCm[1],
|
|
pro.marginCm[0]+colInd*(pro.sizeCm[0]+pro.marginCm[0]), pro.marginCm[1]+rowInd*(pro.sizeCm[1]+pro.marginCm[1]) );
|
|
|
|
|
|
// Main loop of edge printing
|
|
typename EdgeMeshType::EdgeIterator i;
|
|
|
|
// XY projection.
|
|
// It is a classcial ortho projection
|
|
// eg it resolves to a rotation Matrix such that
|
|
// - the passed projDir become the z axis
|
|
// - the passed projUp lie on the upper YZ plane.
|
|
|
|
// First Step align projDir to Z
|
|
Matrix33f rotM = RotationMatrix(pro.projDir,Point3f(0,0,1),false);
|
|
Point3f rotatedUp = rotM * pro.projUp;
|
|
Point3f rotCenter = rotM * pro.projCenter;
|
|
float scale = pro.scale;
|
|
if(scale==0) scale = 2.0/mp.bbox.Diag();
|
|
|
|
for (i = mp.edges.begin(); i != mp.edges.end(); ++i)
|
|
{
|
|
Point3f p0 = (-rotCenter + rotM * ((*i).V(0)->P()))*scale*1000;
|
|
Point3f p1 = (-rotCenter + rotM * ((*i).V(1)->P()))*scale*1000;
|
|
fprintf(fpo, " <line x1=\"%f\" y1=\"%f\" x2=\"%f\" y2=\"%f\" />\n", p0[0],p0[1],p1[0],p1[1]);
|
|
}
|
|
|
|
fprintf(fpo, " </svg>\n");
|
|
fprintf(fpo, "</g>\n");
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
}; // namespace io
|
|
}; // namespace edge
|
|
}; // namespace vcg
|
|
#endif // __VCG_LIB_EXPORTER_SVG
|