archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it. You cannot open issues or pull requests or push a commit.
Files
51f9082c964fda6ba90aa5b503a06f22c5a9ee60
blender-archive/source/blender/freestyle/intern/view_map/ViewMapIO.cpp

1246 lines
28 KiB
C++
Executable File
Raw Blame History

//
// Copyright (C) : Please refer to the COPYRIGHT file distributed
// with this source distribution.
//
// 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 for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
///////////////////////////////////////////////////////////////////////////////
#include "ViewMapIO.h"
#ifdef IRIX
# define WRITE(n) Internal::write<sizeof((n))>(out, (const char*)(&(n)))
# define READ(n) Internal::read<sizeof((n))>(in, (char*)(&(n)))
#else
# define WRITE(n) out.write((const char*)(&(n)), sizeof((n)))
# define READ(n) in.read((char*)(&(n)), sizeof((n)))
#endif
#define WRITE_IF_NON_NULL(ptr) if ((ptr) == NULL) { WRITE(ZERO); } else { WRITE((ptr)->userdata); }
#define READ_IF_NON_NULL(ptr, array) READ(tmp); if (tmp == ZERO) { (ptr) = NULL; } else { (ptr) = (array)[tmp]; }
namespace ViewMapIO {
namespace Internal {
ViewMap* g_vm;
//////////////////// 'load' Functions ////////////////////
inline
int load(istream& in, Vec3r& v) {
if (Options::getFlags() & Options::FLOAT_VECTORS) {
float tmp;
READ(tmp);
v[0] = tmp;
READ(tmp);
v[1] = tmp;
READ(tmp);
v[2] = tmp;
} else {
Vec3r::value_type tmp;
READ(tmp);
v[0] = tmp;
READ(tmp);
v[1] = tmp;
READ(tmp);
v[2] = tmp;
}
return 0;
}
inline
int load(istream& in, Polygon3r& p) {
unsigned tmp;
// Id
READ(tmp);
p.setId(tmp);
// vertices (List)
vector<Vec3r> tmp_vec;
Vec3r v;
READ(tmp);
for (unsigned i = 0; i < tmp; i++) {
load(in, v);
tmp_vec.push_back(v);
}
p.setVertices(tmp_vec);
// min & max
// Already computed (in the SetVertices() method)
return 0;
}
inline
int load(istream& in, Material& m) {
float tmp_array[4];
int i;
// Diffuse
for (i = 0; i < 4; i++)
READ(tmp_array[i]);
m.setDiffuse(tmp_array[0], tmp_array[1], tmp_array[2], tmp_array[3]);
// Specular
for (i = 0; i < 4; i++)
READ(tmp_array[i]);
m.setSpecular(tmp_array[0], tmp_array[1], tmp_array[2], tmp_array[3]);
// Ambient
for (i = 0; i < 4; i++)
READ(tmp_array[i]);
m.setAmbient(tmp_array[0], tmp_array[1], tmp_array[2], tmp_array[3]);
// Emission
for (i = 0; i < 4; i++)
READ(tmp_array[i]);
m.setEmission(tmp_array[0], tmp_array[1], tmp_array[2], tmp_array[3]);
// Shininess
READ(tmp_array[0]);
m.setShininess(tmp_array[0]);
return 0;
}
int load(istream& in, ViewShape* vs) {
if (!vs || !vs->sshape())
return 1;
// SShape
// -> Id
Id::id_type id1, id2;
READ(id1);
READ(id2);
vs->sshape()->setId(Id(id1, id2));
// -> Importance
float importance;
READ(importance);
vs->sshape()->setImportance(importance);
// -> BBox
// Not necessary (only used during view map computatiom)
unsigned i, size, tmp;
// -> Material
READ(size);
vector<Material> materials;
Material m;
for(i=0; i<size; ++i){
load(in, m);
materials.push_back(m);
}
vs->sshape()->setMaterials(materials);
// -> VerticesList (List)
READ(size);
for (i = 0; i < size; i++) {
SVertex* sv;
READ_IF_NON_NULL(sv, g_vm->SVertices());
vs->sshape()->AddNewVertex(sv);
}
// -> Chains (List)
READ(size);
for (i = 0; i < size; i++) {
FEdge* fe;
READ_IF_NON_NULL(fe, g_vm->FEdges());
vs->sshape()->AddChain(fe);
}
// -> EdgesList (List)
READ(size);
for (i = 0; i < size; i++) {
FEdge* fe;
READ_IF_NON_NULL(fe, g_vm->FEdges());
vs->sshape()->AddEdge(fe);
}
// ViewEdges (List)
READ(size);
for (i = 0; i < size; i++) {
ViewEdge* ve;
READ_IF_NON_NULL(ve, g_vm->ViewEdges());
vs->AddEdge(ve);
}
// ViewVertices (List)
READ(size);
for (i = 0; i < size; i++) {
ViewVertex* vv;
READ_IF_NON_NULL(vv, g_vm->ViewVertices());
vs->AddVertex(vv);
}
return 0;
}
int load(istream& in, FEdge* fe) {
if (!fe)
return 1;
bool b;
FEdgeSmooth *fesmooth = 0;
FEdgeSharp * fesharp = 0;
if(fe->isSmooth()){
fesmooth = dynamic_cast<FEdgeSmooth*>(fe);
}else{
fesharp = dynamic_cast<FEdgeSharp*>(fe);
}
// Id
Id::id_type id1, id2;
READ(id1);
READ(id2);
fe->setId(Id(id1, id2));
// Nature
Nature::EdgeNature nature;
READ(nature);
fe->setNature(nature);
// hasVisibilityPoint
// bool b;
// READ(b);
// fe->setHasVisibilityPoint(b);
Vec3r v;
unsigned int matindex;
// VisibilityPointA
// load(in, v);
// fe->setVisibilityPointA(v);
// VisibilityPointB
// load(in, v);
// fe->setVisibilityPointB(v);
if(fe->isSmooth()){
// Normal
load(in, v);
fesmooth->setNormal(v);
// Material
READ(matindex);
fesmooth->setMaterialIndex(matindex);
}else{
// aNormal
load(in, v);
fesharp->setNormalA(v);
// bNormal
load(in, v);
fesharp->setNormalB(v);
// Materials
READ(matindex);
fesharp->setaMaterialIndex(matindex);
READ(matindex);
fesharp->setbMaterialIndex(matindex);
}
unsigned tmp;
// VertexA
SVertex* sva;
READ_IF_NON_NULL(sva, g_vm->SVertices());
fe->setVertexA(sva);
// VertexB
SVertex* svb;
READ_IF_NON_NULL(svb, g_vm->SVertices());
fe->setVertexB(svb);
// NextEdge
FEdge* nfe;
READ_IF_NON_NULL(nfe, g_vm->FEdges());
fe->setNextEdge(nfe);
// PreviousEdge
FEdge* pfe;
READ_IF_NON_NULL(pfe, g_vm->FEdges());
fe->setPreviousEdge(pfe);
// ViewEdge
ViewEdge* ve;
READ_IF_NON_NULL(ve, g_vm->ViewEdges());
fe->setViewEdge(ve);
// Face
// Not necessary (only used during view map computatiom)
Polygon3r p;
// aFace
load(in, p);
fe->setaFace(p);
// occludeeEmpty
READ(b);
fe->setOccludeeEmpty(b);
// occludeeIntersection
load(in, v);
fe->setOccludeeIntersection(v);
return 0;
}
int load(istream& in, SVertex* sv) {
if (!sv)
return 1;
// Id
Id::id_type id1, id2;
READ(id1);
READ(id2);
sv->setId(Id(id1, id2));
Vec3r v;
// Point3D
load(in, v);
sv->setPoint3D(v);
// Point2D
load(in, v);
sv->setPoint2D(v);
unsigned tmp;
// Shape
ViewShape* vs;
READ_IF_NON_NULL(vs, g_vm->ViewShapes());
sv->setShape(vs->sshape());
// pViewVertex
ViewVertex* vv;
READ_IF_NON_NULL(vv, g_vm->ViewVertices());
sv->setViewVertex(vv);
unsigned i, size;
// Normals (List)
READ(size);
for (i = 0; i < size; i++) {
load(in, v);
sv->AddNormal(v);
}
// FEdges (List)
READ(size);
FEdge* fe;
for (i = 0; i < size; i++) {
READ_IF_NON_NULL(fe, g_vm->FEdges());
sv->AddFEdge(fe);
}
return 0;
}
int load(istream& in, ViewEdge* ve) {
if (!ve)
return 1;
unsigned tmp;
// Id
Id::id_type id1, id2;
READ(id1);
READ(id2);
ve->setId(Id(id1, id2));
// Nature
Nature::EdgeNature nature;
READ(nature);
ve->setNature(nature);
// QI
READ(tmp);
ve->setQI(tmp);
// Shape
ViewShape* vs;
READ_IF_NON_NULL(vs, g_vm->ViewShapes());
ve->setShape(vs);
// aShape
ViewShape* avs;
READ_IF_NON_NULL(avs, g_vm->ViewShapes());
ve->setaShape(avs);
// FEdgeA
FEdge* fea;
READ_IF_NON_NULL(fea, g_vm->FEdges());
ve->setFEdgeA(fea);
// FEdgeB
FEdge* feb;
READ_IF_NON_NULL(feb, g_vm->FEdges());
ve->setFEdgeB(feb);
// A
ViewVertex* vva;
READ_IF_NON_NULL(vva, g_vm->ViewVertices());
ve->setA(vva);
// B
ViewVertex* vvb;
READ_IF_NON_NULL(vvb, g_vm->ViewVertices());
ve->setB(vvb);
// Occluders (List)
if (!(Options::getFlags() & Options::NO_OCCLUDERS)) {
unsigned size;
READ(size);
ViewShape* vso;
for (unsigned i = 0; i < size; i++) {
READ_IF_NON_NULL(vso, g_vm->ViewShapes());
ve->AddOccluder(vso);
}
}
return 0;
}
int load(istream& in, ViewVertex* vv) {
if (!vv)
return 1;
unsigned tmp;
bool b;
// Nature
Nature::VertexNature nature;
READ(nature);
vv->setNature(nature);
if (vv->getNature() & Nature::T_VERTEX) {
TVertex* tv = dynamic_cast<TVertex*>(vv);
// Id
Id::id_type id1, id2;
READ(id1);
READ(id2);
tv->setId(Id(id1, id2));
// FrontSVertex
SVertex* fsv;
READ_IF_NON_NULL(fsv, g_vm->SVertices());
tv->setFrontSVertex(fsv);
// BackSVertex
SVertex* bsv;
READ_IF_NON_NULL(bsv, g_vm->SVertices());
tv->setBackSVertex(bsv);
// FrontEdgeA
ViewEdge* fea;
READ_IF_NON_NULL(fea, g_vm->ViewEdges());
READ(b);
tv->setFrontEdgeA(fea, b);
// FrontEdgeB
ViewEdge* feb;
READ_IF_NON_NULL(feb, g_vm->ViewEdges());
READ(b);
tv->setFrontEdgeB(feb, b);
// BackEdgeA
ViewEdge* bea;
READ_IF_NON_NULL(bea, g_vm->ViewEdges());
READ(b);
tv->setBackEdgeA(bea, b);
// BackEdgeB
ViewEdge* beb;
READ_IF_NON_NULL(beb, g_vm->ViewEdges());
READ(b);
tv->setBackEdgeB(beb, b);
}
else if (vv->getNature() & Nature::NON_T_VERTEX) {
NonTVertex* ntv = dynamic_cast<NonTVertex*>(vv);
// SVertex
SVertex* sv;
READ_IF_NON_NULL(sv, g_vm->SVertices());
ntv->setSVertex(sv);
// ViewEdges (List)
unsigned size;
READ(size);
ViewEdge* ve;
for (unsigned i = 0; i < size; i++) {
READ_IF_NON_NULL(ve, g_vm->ViewEdges());
READ(b);
ntv->AddViewEdge(ve, b);
}
}
return 0;
}
//////////////////// 'save' Functions ////////////////////
inline
int save(ostream& out, const Vec3r& v) {
if (Options::getFlags() & Options::FLOAT_VECTORS) {
float tmp;
tmp = v[0];
WRITE(tmp);
tmp = v[1];
WRITE(tmp);
tmp = v[2];
WRITE(tmp);
} else {
Vec3r::value_type tmp;
tmp = v[0];
WRITE(tmp);
tmp = v[1];
WRITE(tmp);
tmp = v[2];
WRITE(tmp);
}
return 0;
}
inline
int save(ostream& out, const Polygon3r& p) {
unsigned tmp;
// Id
tmp = p.getId();
WRITE(tmp);
// vertices (List)
tmp = p.getVertices().size();
WRITE(tmp);
for (vector<Vec3r>::const_iterator i = p.getVertices().begin();
i != p.getVertices().end(); i++) {
save(out, *i);
}
// min & max
// Do not need to be saved
return 0;
}
inline
int save(ostream& out, const Material& m) {
unsigned i;
// Diffuse
for (i = 0; i < 4; i++)
WRITE(m.diffuse()[i]);
// Specular
for (i = 0; i < 4; i++)
WRITE(m.specular()[i]);
// Ambient
for (i = 0; i < 4; i++)
WRITE(m.ambient()[i]);
// Emission
for (i = 0; i < 4; i++)
WRITE(m.emission()[i]);
// Shininess
float shininess = m.shininess();
WRITE(shininess);
return 0;
}
int save(ostream& out, ViewShape* vs) {
if (!vs || !vs->sshape()) {
cerr << "Warning: null ViewShape" << endl;
return 1;
}
unsigned tmp;
// SShape
// -> Id
Id::id_type id = vs->sshape()->getId().getFirst();
WRITE(id);
id = vs->sshape()->getId().getSecond();
WRITE(id);
// -> Importance
float importance = vs->sshape()->importance();
WRITE(importance);
// -> BBox
// Not necessary (only used during view map computatiom)
// -> Material
unsigned size = vs->sshape()->materials().size();
WRITE(size);
for(unsigned i=0; i<size; ++i)
save(out, vs->sshape()->material(i));
// -> VerticesList (List)
tmp = vs->sshape()->getVertexList().size();
WRITE(tmp);
for (vector<SVertex*>::const_iterator i1 = vs->sshape()->getVertexList().begin();
i1 != vs->sshape()->getVertexList().end(); i1++)
WRITE_IF_NON_NULL(*i1);
// -> Chains (List)
tmp = vs->sshape()->getChains().size();
WRITE(tmp);
for (vector<FEdge*>::const_iterator i2 = vs->sshape()->getChains().begin();
i2 != vs->sshape()->getChains().end(); i2++)
WRITE_IF_NON_NULL(*i2);
// -> EdgesList (List)
tmp = vs->sshape()->getEdgeList().size();
WRITE(tmp);
for (vector<FEdge*>::const_iterator i3 = vs->sshape()->getEdgeList().begin();
i3 != vs->sshape()->getEdgeList().end(); i3++)
WRITE_IF_NON_NULL(*i3);
// ViewEdges (List)
tmp = vs->edges().size();
WRITE(tmp);
for (vector<ViewEdge*>::const_iterator i4 = vs->edges().begin();
i4 != vs->edges().end(); i4++)
WRITE_IF_NON_NULL(*i4);
// ViewVertices (List)
tmp = vs->vertices().size();
WRITE(tmp);
for (vector<ViewVertex*>::const_iterator i5 = vs->vertices().begin();
i5 != vs->vertices().end(); i5++)
WRITE_IF_NON_NULL(*i5);
return 0;
}
int save(ostream& out, FEdge* fe) {
if (!fe) {
cerr << "Warning: null FEdge" << endl;
return 1;
}
FEdgeSmooth * fesmooth = dynamic_cast<FEdgeSmooth*>(fe);
FEdgeSharp * fesharp = dynamic_cast<FEdgeSharp*>(fe);
// Id
Id::id_type id = fe->getId().getFirst();
WRITE(id);
id = fe->getId().getSecond();
WRITE(id);
// Nature
Nature::EdgeNature nature = fe->getNature();
WRITE(nature);
bool b;
// hasVisibilityPoint
// b = fe->hasVisibilityPoint();
// WRITE(b);
// VisibilityPointA
// save(out, fe->visibilityPointA());
//
// // VisibilityPointB
// save(out, fe->visibilityPointB());
unsigned index;
if(fe->isSmooth()){
// normal
save(out, fesmooth->normal());
// material
index = fesmooth->materialIndex();
WRITE(index);
}else{
// aNormal
save(out, fesharp->normalA());
// bNormal
save(out, fesharp->normalB());
// aMaterial
index = fesharp->aMaterialIndex();
WRITE(index);
// bMaterial
index = fesharp->bMaterialIndex();
WRITE(index);
}
// VertexA
WRITE_IF_NON_NULL(fe->vertexA());
// VertexB
WRITE_IF_NON_NULL(fe->vertexB());
// NextEdge
WRITE_IF_NON_NULL(fe->nextEdge());
// PreviousEdge
WRITE_IF_NON_NULL(fe->previousEdge());
// ViewEdge
WRITE_IF_NON_NULL(fe->viewedge());
// Face
// Not necessary (only used during view map computatiom)
// aFace
save(out, (Polygon3r&)fe->aFace());
// occludeeEmpty
b = fe->getOccludeeEmpty();
WRITE(b);
// occludeeIntersection
save(out, fe->getOccludeeIntersection());
return 0;
}
int save(ostream& out, SVertex* sv) {
if (!sv) {
cerr << "Warning: null SVertex" << endl;
return 1;
}
unsigned tmp;
// Id
Id::id_type id = sv->getId().getFirst();
WRITE(id);
id = sv->getId().getSecond();
WRITE(id);
Vec3r v;
// Point3D
v = sv->point3D();
save(out, sv->point3D());
// Point2D
v = sv->point2D();
save(out, v);
// Shape
WRITE_IF_NON_NULL(sv->shape());
// pViewVertex
WRITE_IF_NON_NULL(sv->viewvertex());
// Normals (List)
// Note: the 'size()' method of a set doesn't seem to return the
// actual size of the given set, so we have to hack it...
set<Vec3r>::const_iterator i;
for (i = sv->normals().begin(), tmp = 0;
i != sv->normals().end();
i++, tmp++);
WRITE(tmp);
for (i = sv->normals().begin(); i != sv->normals().end(); i++)
save(out, *i);
// FEdges (List)
tmp = sv->fedges().size();
WRITE(tmp);
for (vector<FEdge*>::const_iterator j = sv->fedges_begin();
j != sv->fedges_end(); j++)
WRITE_IF_NON_NULL(*j);
return 0;
}
int save(ostream& out, ViewEdge* ve) {
if (!ve) {
cerr << "Warning: null ViewEdge" << endl;
return 1;
}
unsigned tmp;
// Id
Id::id_type id = ve->getId().getFirst();
WRITE(id);
id = ve->getId().getSecond();
WRITE(id);
// Nature
Nature::EdgeNature nature = ve->getNature();
WRITE(nature);
// QI
unsigned qi = ve->qi();
WRITE(qi);
// Shape
WRITE_IF_NON_NULL(ve->shape());
// aShape
WRITE_IF_NON_NULL(ve->aShape());
// FEdgeA
WRITE_IF_NON_NULL(ve->fedgeA());
// FEdgeB
WRITE_IF_NON_NULL(ve->fedgeB());
// A
WRITE_IF_NON_NULL(ve->A());
// B
WRITE_IF_NON_NULL(ve->B());
// Occluders (List)
if (!(Options::getFlags() & Options::NO_OCCLUDERS)) {
tmp = ve->occluders().size();
WRITE(tmp);
for (vector<ViewShape*>::const_iterator i = ve->occluders().begin();
i != ve->occluders().end(); i++)
WRITE_IF_NON_NULL((*i));
}
return 0;
}
int save(ostream& out, ViewVertex* vv) {
if (!vv) {
cerr << "Warning: null ViewVertex" << endl;
return 1;
}
// Nature
Nature::VertexNature nature = vv->getNature();
WRITE(nature);
if (vv->getNature() & Nature::T_VERTEX) {
TVertex* tv = dynamic_cast<TVertex*>(vv);
// Id
Id::id_type id = tv->getId().getFirst();
WRITE(id);
id = tv->getId().getSecond();
WRITE(id);
// FrontSVertex
WRITE_IF_NON_NULL(tv->frontSVertex());
// BackSVertex
WRITE_IF_NON_NULL(tv->backSVertex());
// FrontEdgeA
WRITE_IF_NON_NULL(tv->frontEdgeA().first);
WRITE(tv->frontEdgeA().second);
// FrontEdgeB
WRITE_IF_NON_NULL(tv->frontEdgeB().first);
WRITE(tv->frontEdgeB().second);
// BackEdgeA
WRITE_IF_NON_NULL(tv->backEdgeA().first);
WRITE(tv->backEdgeA().second);
// BackEdgeB
WRITE_IF_NON_NULL(tv->backEdgeB().first);
WRITE(tv->backEdgeB().second);
}
else if (vv->getNature() & Nature::NON_T_VERTEX) {
NonTVertex* ntv = dynamic_cast<NonTVertex*>(vv);
// SVertex
WRITE_IF_NON_NULL(ntv->svertex());
// ViewEdges (List)
unsigned size = ntv->viewedges().size();
WRITE(size);
vector<ViewVertex::directedViewEdge>::const_iterator i = ntv->viewedges().begin();
for ( ; i != ntv->viewedges().end(); i++){
WRITE_IF_NON_NULL(i->first);
WRITE(i->second);
}
} else {
cerr << "Warning: unexpected ViewVertex nature" << endl;
return 1;
}
return 0;
}
} // End of namespace Internal
//////////////////// "Public" 'load' and 'save' functions ////////////////////
#define SET_PROGRESS(n) if (pb) pb->setProgress((n))
int load(istream& in, ViewMap* vm, ProgressBar* pb) {
if (!vm)
return 1;
//soc unused - unsigned tmp;
int err = 0;
Internal::g_vm = vm;
// Management of the progress bar (if present)
if (pb) {
pb->reset();
pb->setLabelText("Loading View Map...");
pb->setTotalSteps(6);
pb->setProgress(0);
}
// Read and set the options
unsigned char flags;
READ(flags);
Options::setFlags(flags);
// Read the size of the five ViewMap's lists (with some extra informations for the ViewVertices)
// and instantiate them (with default costructors)
unsigned vs_s, fe_s, fe_rle1, fe_rle2, sv_s, ve_s, vv_s, vv_rle1, vv_rle2;
READ(vs_s);
READ(fe_s);
if (fe_s) {
bool b;
READ(b);
for (READ(fe_rle1), fe_rle2 = 0;
fe_rle1 < fe_s+1;
fe_rle2 = fe_rle1, READ(fe_rle1)) {
if (b) {
for (unsigned i = fe_rle2; i < fe_rle1; i++) {
FEdgeSmooth * fes = new FEdgeSmooth;
vm->AddFEdge(fes);
}
b = !b;
}
else if (!b) {
for (unsigned i = fe_rle2; i < fe_rle1; i++) {
FEdgeSharp * fes = new FEdgeSharp;
vm->AddFEdge(fes);
}
b = !b;
}
}
}
READ(sv_s);
READ(ve_s);
READ(vv_s);
if (vv_s) {
Nature::VertexNature nature;
READ(nature);
for (READ(vv_rle1), vv_rle2 = 0;
vv_rle1 < vv_s+1;
vv_rle2 = vv_rle1, READ(vv_rle1)) {
if (nature & Nature::T_VERTEX) {
for (unsigned i = vv_rle2; i < vv_rle1; i++) {
TVertex* tv = new TVertex();
vm->AddViewVertex(tv);
}
nature = Nature::NON_T_VERTEX;
}
else if (nature & Nature::NON_T_VERTEX) {
for (unsigned i = vv_rle2; i < vv_rle1; i++) {
NonTVertex* ntv = new NonTVertex();
vm->AddViewVertex(ntv);
}
nature = Nature::T_VERTEX;
}
}
}
for (unsigned i0 = 0; i0 < vs_s; i0++) {
SShape* ss = new SShape();
ViewShape* vs = new ViewShape();
vs->setSShape(ss);
ss->setViewShape(vs);
vm->AddViewShape(vs);
}
// for (unsigned i1 = 0; i1 < fe_s; i1++) {
// FEdge* fe = new FEdge();
// vm->AddFEdge(fe);
// }
for (unsigned i2 = 0; i2 < sv_s; i2++) {
SVertex* sv = new SVertex();
vm->AddSVertex(sv);
}
for (unsigned i3 = 0; i3 < ve_s; i3++) {
ViewEdge* ve = new ViewEdge();
vm->AddViewEdge(ve);
}
// Read the values for all the objects created above
SET_PROGRESS(1);
for (vector<ViewShape*>::const_iterator i4 = vm->ViewShapes().begin();
i4 != vm->ViewShapes().end(); i4++)
err += Internal::load(in, *i4);
SET_PROGRESS(2);
for (vector<FEdge*>::const_iterator i5 = vm->FEdges().begin();
i5 != vm->FEdges().end(); i5++)
err += Internal::load(in, *i5);
SET_PROGRESS(3);
for (vector<SVertex*>::const_iterator i6 = vm->SVertices().begin();
i6 != vm->SVertices().end(); i6++)
err += Internal::load(in, *i6);
SET_PROGRESS(4);
for (vector<ViewEdge*>::const_iterator i7 = vm->ViewEdges().begin();
i7 != vm->ViewEdges().end(); i7++)
err += Internal::load(in, *i7);
SET_PROGRESS(5);
for (vector<ViewVertex*>::const_iterator i8 = vm->ViewVertices().begin();
i8 != vm->ViewVertices().end(); i8++)
err += Internal::load(in, *i8);
SET_PROGRESS(6);
// Read the shape id to index mapping
unsigned map_s;
READ(map_s);
unsigned id,index;
for(unsigned i4=0;i4<map_s;++i4){
READ(id);
READ(index);
vm->shapeIdToIndexMap()[id] = index;
}
return err;
}
int save(ostream& out, ViewMap* vm, ProgressBar* pb) {
if (!vm)
return 1;
int err = 0;
// Management of the progress bar (if present)
if (pb) {
pb->reset();
pb->setLabelText("Saving View Map...");
pb->setTotalSteps(6);
pb->setProgress(0);
}
// For every object, initialize its userdata member to its index in the ViewMap list
for (unsigned i0 = 0; i0 < vm->ViewShapes().size(); i0++) {
vm->ViewShapes()[i0]->userdata = (void*)i0;
vm->ViewShapes()[i0]->sshape()->userdata = (void*)i0;
}
for (unsigned i1 = 0; i1 < vm->FEdges().size(); i1++)
vm->FEdges()[i1]->userdata = (void*)i1;
for (unsigned i2 = 0; i2 < vm->SVertices().size(); i2++)
vm->SVertices()[i2]->userdata = (void*)i2;
for (unsigned i3 = 0; i3 < vm->ViewEdges().size(); i3++)
vm->ViewEdges()[i3]->userdata = (void*)i3;
for (unsigned i4 = 0; i4 < vm->ViewVertices().size(); i4++)
vm->ViewVertices()[i4]->userdata = (void*)i4;
// Write the current options
unsigned char flags = Options::getFlags();
WRITE(flags);
// Write the size of the five lists (with some extra informations for the ViewVertices)
unsigned size;
size = vm->ViewShapes().size();
WRITE(size);
size = vm->FEdges().size();
WRITE(size);
if (size) {
bool b = vm->FEdges()[0]->isSmooth();
WRITE(b);
for (unsigned i = 0; i < size; i++) {
while (i < size && (vm->FEdges()[i]->isSmooth() == b))
i++;
if (i < size) {
WRITE(i);
b = !b;
}
}
WRITE(size);
size++;
WRITE(size);
}
size = vm->SVertices().size();
WRITE(size);
size = vm->ViewEdges().size();
WRITE(size);
size = vm->ViewVertices().size();
WRITE(size);
if (size) {
Nature::VertexNature nature = vm->ViewVertices()[0]->getNature();
WRITE(nature);
nature &= ~Nature::VIEW_VERTEX;
for (unsigned i = 0; i < size; i++) {
while (i < size && (vm->ViewVertices()[i]->getNature() & nature))
i++;
if (i < size) {
WRITE(i);
nature = vm->ViewVertices()[i]->getNature() & ~Nature::VIEW_VERTEX;
}
}
WRITE(size);
size++;
WRITE(size);
}
// Write all the elts of the ViewShapes List
SET_PROGRESS(1);
for (vector<ViewShape*>::const_iterator i5 = vm->ViewShapes().begin();
i5 != vm->ViewShapes().end(); i5++)
err += Internal::save(out, *i5);
SET_PROGRESS(2);
for (vector<FEdge*>::const_iterator i6 = vm->FEdges().begin();
i6 != vm->FEdges().end(); i6++)
err += Internal::save(out, *i6);
SET_PROGRESS(3);
for (vector<SVertex*>::const_iterator i7 = vm->SVertices().begin();
i7 != vm->SVertices().end(); i7++)
err += Internal::save(out, *i7);
SET_PROGRESS(4);
for (vector<ViewEdge*>::const_iterator i8 = vm->ViewEdges().begin();
i8 != vm->ViewEdges().end(); i8++)
err += Internal::save(out, *i8);
SET_PROGRESS(5);
for (vector<ViewVertex*>::const_iterator i9 = vm->ViewVertices().begin();
i9 != vm->ViewVertices().end(); i9++)
err += Internal::save(out, *i9);
// Write the shape id to index mapping
size = vm->shapeIdToIndexMap().size();
WRITE(size);
unsigned id,index;
for(ViewMap::id_to_index_map::iterator mit=vm->shapeIdToIndexMap().begin(), mitend=vm->shapeIdToIndexMap().end(); mit!=mitend; ++mit){
id = mit->first;
index = mit->second;
WRITE(id);
WRITE(index);
}
// Reset 'userdata' members
for (vector<ViewShape*>::const_iterator j0 = vm->ViewShapes().begin();
j0 != vm->ViewShapes().end(); j0++) {
(*j0)->userdata = 0;
(*j0)->sshape()->userdata = 0;
}
for (vector<FEdge*>::const_iterator j1 = vm->FEdges().begin();
j1 != vm->FEdges().end(); j1++)
(*j1)->userdata = 0;
for (vector<SVertex*>::const_iterator j2 = vm->SVertices().begin();
j2 != vm->SVertices().end(); j2++)
(*j2)->userdata = 0;
for (vector<ViewEdge*>::const_iterator j3 = vm->ViewEdges().begin();
j3 != vm->ViewEdges().end(); j3++)
(*j3)->userdata = 0;
for (vector<ViewVertex*>::const_iterator j4 = vm->ViewVertices().begin();
j4 != vm->ViewVertices().end(); j4++)
(*j4)->userdata = 0;
SET_PROGRESS(6);
return err;
}
//////////////////// Options ////////////////////
namespace Options {
namespace Internal {
static unsigned char g_flags = 0;
static string g_models_path;
} // End of namespace Internal
void setFlags(const unsigned char flags) {
Internal::g_flags = flags;
}
void addFlags(const unsigned char flags) {
Internal::g_flags |= flags;
}
void rmFlags(const unsigned char flags) {
Internal::g_flags &= ~flags;
}
unsigned char getFlags() {
return Internal::g_flags;
}
void setModelsPath(const string& path) {
Internal::g_models_path = path;
}
string getModelsPath() {
return Internal::g_models_path;
}
}; // End of namepace Options
} // End of namespace ViewMapIO
View Git Blame Copy Permalink