void displayDSS2d( Viewer3D<space, kspace> & viewer,
const KSpace & ks, const StandardDSS6Computer & dss3d,
const DGtal::Color & color2d )
{
typedef typename StandardDSS6Computer::ConstIterator ConstIterator3d;
typedef typename StandardDSS6Computer::ArithmeticalDSSComputer2d ArithmeticalDSSComputer2d;
typedef typename ArithmeticalDSSComputer2d::ConstIterator ConstIterator2d;
typedef typename ArithmeticalDSSComputer2d::Point Point2d;
typedef typename KSpace::Cell Cell;
typedef typename KSpace::Point Point3d;
typedef DGtal::PointVector<2,double> PointD2d;
typedef typename Display3D<>::BallD3D PointD3D;
Point3d b = ks.lowerBound();
for ( DGtal::Dimension i = 0; i < 3; ++i )
{
const typename ArithmeticalDSSComputer2d::Primitive & dss2d
= dss3d.arithmeticalDSS2d( i ).primitive();
// draw 2D bounding boxes for each arithmetical dss 2D.
std::vector<PointD2d> pts2d;
pts2d.push_back( dss2d.project(dss2d.back(), dss2d.Uf()) );
pts2d.push_back( dss2d.project(dss2d.back(), dss2d.Lf()) );
pts2d.push_back( dss2d.project(dss2d.front(), dss2d.Lf()) );
pts2d.push_back( dss2d.project(dss2d.front(), dss2d.Uf()) );
std::vector<PointD3D> bb;
PointD3D p3;
for ( unsigned int j = 0; j < pts2d.size(); ++j )
{
switch (i) {
case 0: p3.center[0] = (double) b[ i ]-0.5; p3.center[1] = pts2d[ j ][ 0 ]; p3.center[2] = pts2d[ j ][ 1 ]; break;
case 1: p3.center[0] = pts2d[ j ][ 0 ]; p3.center[1] = (double) b[ i ]-0.5; p3.center[2] = pts2d[ j ][ 1 ]; break;
case 2: p3.center[0] = pts2d[ j ][ 0 ]; p3.center[1] = pts2d[ j ][ 1 ]; p3.center[2] = (double) b[ i ]-0.5; break;
}
bb.push_back( p3 );
}
for ( unsigned int j = 0; j < pts2d.size(); ++j ){
viewer.setLineColor(color2d);
viewer.addLine( DGtal::Z3i::RealPoint(bb[ j ].center[0], bb[ j ].center[1], bb[ j ].center[2]),
DGtal::Z3i::RealPoint(bb[ (j+1)%4 ].center[0], bb[ (j+1)%4 ].center[1], bb[ (j+1)%4 ].center[2]),
MS3D_LINESIZE );
}
} // for ( DGtal::Dimension i = 0; i < 3; ++i )
}
void displayDSS3dTangent( Viewer3D<space, kspace> & viewer,
const KSpace & ks, const StandardDSS6Computer & dss3d,
const DGtal::Color & color3d )
{
typedef typename StandardDSS6Computer::Point3d Point;
typedef typename StandardDSS6Computer::PointD3d PointD3d;
typedef typename Display3D<>::BallD3D PointD3D;
Point directionZ3;
PointD3d P1, P2, direction, intercept, thickness;
dss3d.getParameters( directionZ3, intercept, thickness );
assign( direction, directionZ3 );
direction /= direction.norm();
assign( P1, *dss3d.begin() );
assign( P2, *(dss3d.end()-1) );
double t1 = (P1 - intercept).dot( direction );
double t2 = (P2 - intercept).dot( direction );
PointD3d Q1 = intercept + t1 * direction;
PointD3d Q2 = intercept + t2 * direction;
viewer.setLineColor(color3d);
viewer.addLine( DGtal::Z3i::RealPoint(Q1[ 0 ]-0.5, Q1[ 1 ]-0.5, Q1[ 2 ]-0.5),
DGtal::Z3i::RealPoint(Q2[ 0 ]-0.5, Q2[ 1 ]-0.5, Q2[ 2 ]-0.5),
MS3D_LINESIZE );
}
int main( int argc, char** argv )
{
QApplication application(argc,argv);
using namespace DGtal;
using namespace DGtal::Z3i;
typedef ImageContainerBySTLVector<Domain,unsigned char> GrayLevelImage3D;
typedef ImageContainerBySTLVector<Domain,float> FloatImage3D;
typedef DistanceToMeasure<FloatImage3D> Distance;
if ( argc <= 3 ) return 1;
GrayLevelImage3D img = GenericReader<GrayLevelImage3D>::import( argv[ 1 ] );
float mass = atof( argv[ 2 ] );
float rmax = atof( argv[ 3 ] );
float R = atof( argv[ 4 ] );
float r = atof( argv[ 5 ] );
float T1 = atof( argv[ 6 ] );
float T2 = atof( argv[ 7 ] );
unsigned char seuil = atof( argv[ 8 ] );
{
Viewer3D<> viewer;
viewer.show();
for ( Domain::ConstIterator it = img.domain().begin(), itE = img.domain().end();
it != itE; ++it )
{
// std::cout << *it << " " << (int) img( *it ) << endl;
if ( img( *it ) > seuil ) viewer << *it;
}
viewer << Viewer3D<>::updateDisplay;
application.exec();
}
FloatImage3D fimg( img.domain() );
FloatImage3D::Iterator outIt = fimg.begin();
for ( GrayLevelImage3D::ConstIterator it = img.begin(), itE = img.end();
it != itE; ++it )
{
float v = 2.0 * ((float)*it) / seuil; // 255.0;
v = std::min( 255.0f, v );
*outIt++ = v;
}
trace.beginBlock( "Computing delta-distance." );
Distance delta( mass, fimg, rmax );
const FloatImage3D& d2 = delta.myDistance2;
trace.endBlock();
float m = 0.0f;
for ( typename Domain::ConstIterator it = d2.domain().begin(),
itE = d2.domain().end(); it != itE; ++it )
{
Point p = *it;
float v = sqrt( d2( p ) );
m = std::max( v, m );
}
// GradientColorMap<float> cmap_grad( 0, m );
// cmap_grad.addColor( Color( 255, 255, 255 ) );
// cmap_grad.addColor( Color( 255, 255, 0 ) );
// cmap_grad.addColor( Color( 255, 0, 0 ) );
// cmap_grad.addColor( Color( 0, 255, 0 ) );
// cmap_grad.addColor( Color( 0, 0, 255 ) );
// cmap_grad.addColor( Color( 0, 0, 0 ) );
// QApplication application(argc,argv);
// Viewer3D<> viewer;
// viewer.show();
// for ( typename Domain::ConstIterator it = d2.domain().begin(),
// itE = d2.domain().end(); it != itE; ++it )
// {
// Point p = *it;
// float v = sqrt( d2( p ) );
// v = std::min( (float)m, std::max( v, 0.0f ) );
// viewer << CustomColors3D(Color(cmap_grad(v).red(), cmap_grad(v).green(), cmap_grad(v).blue(), 120), Color(cmap_grad(v).red(), cmap_grad(v).green(), cmap_grad(v).blue(),120) )
// << p;
// RealVector grad = delta.projection( p );
// viewer.addLine( p, p+grad );
// }
// std::cout << endl;
// viewer << Viewer3D<>::updateDisplay;
// application.exec();
trace.beginBlock( "Computing delta-VCM." );
typedef DeltaVCM< Distance > DVCM;
typedef DVCM::Matrix Matrix;
DVCM dvcm( delta, R, r );
trace.endBlock();
typedef EigenDecomposition<3,float> LinearAlgebraTool;
typedef functors::HatPointFunction<Point,float> KernelFunction;
KernelFunction chi( 1.0, r );
// Flat zones are metallic blue, slightly curved zones are white,
// more curved zones are yellow till red.
double size = 1.0;
GradientColorMap<double> colormap( 0.0, T2 );
colormap.addColor( Color( 128, 128, 255 ) );
colormap.addColor( Color( 255, 255, 255 ) );
colormap.addColor( Color( 255, 255, 0 ) );
colormap.addColor( Color( 255, 0, 0 ) );
Matrix vcm_r, evec, null;
typedef PointVector<3,float> RealVector3f;
RealVector3f eval;
Viewer3D<> viewer;
viewer.show();
for ( Domain::ConstIterator it = dvcm.domain().begin(), itE = dvcm.domain().end();
it != itE; ++it )
{
// Compute VCM and diagonalize it.
Point p = *it;
vcm_r = dvcm.measure( chi, p );
if ( vcm_r == null ) continue;
LinearAlgebraTool::getEigenDecomposition( vcm_r, evec, eval );
//double feature = eval[ 0 ] / ( eval[ 0 ] + eval[ 1 ] );
eval[ 0 ] = std::max( eval[ 0 ], 0.00001f );
float tubular = ( eval[ 2 ] <= 0.00001f ) // (R*R/4.0) )
? 0
: ( ( eval[ 1 ] + eval[ 2 ] ) / ( eval[ 0 ] + eval[ 1 ] + eval[ 2 ] ) );
float bound = T1;
float tubular2 = tubular * (eval[ 0 ] + eval[ 1 ] + eval[ 2 ] ) / (R*R*r*r*3.14f/12.0f);
float display = tubular2 <= bound ? 0.0f : ( tubular2 - bound ) / (1.0f - bound);
//: eval[ 1 ] / ( 1.0 + eval[ 0 ] ) / ( 1.0 + delta( p )*delta( p ) );
//: eval[ 1 ] * eval[ 1 ] / ( 1.0 + eval[ 0 ] ) / ( 1.0 + delta( p ) );
if (display > 0.01f)
trace.info() << "l0=" << eval[ 0 ] << " l1=" << eval[ 1 ]
<< " tub=" << tubular
<< " tub2=" << tubular2
<< " disp=" << display << std::endl;
if (display > 0.5f*T2 )
{
viewer << CustomColors3D( Color::Black,
colormap( display > T2 ? T2 : display ) )
<< p;
RealVector normal = evec.column( 0 );
RealPoint rp( p[ 0 ], p[ 1 ] );
viewer.addLine( rp - size*normal, rp + size*normal );
}
}
viewer << Viewer3D<>::updateDisplay;
application.exec();
return 0;
}
int main( int argc, char** argv )
{
using namespace DGtal;
using namespace DGtal::Z3i;
typedef ImageContainerBySTLVector<Domain,unsigned char> GrayLevelImage3D;
typedef ImageContainerBySTLVector<Domain,float> FloatImage3D;
typedef DistanceToMeasure<FloatImage3D> Distance;
if ( argc <= 3 ) return 1;
GrayLevelImage3D img = GenericReader<GrayLevelImage3D>::import( argv[ 1 ] );
double mass = atof( argv[ 2 ] );
double rmax = atof( argv[ 3 ] );
FloatImage3D fimg( img.domain() );
FloatImage3D::Iterator outIt = fimg.begin();
for ( GrayLevelImage3D::ConstIterator it = img.begin(), itE = img.end();
it != itE; ++it )
{
float v = ((float)*it) / 255.0;
*outIt++ = v;
}
trace.beginBlock( "Computing delta-distance." );
Distance delta( mass, fimg, rmax );
const FloatImage3D& d2 = delta.myDistance2;
trace.endBlock();
float m = 0.0f;
for ( typename Domain::ConstIterator it = d2.domain().begin(),
itE = d2.domain().end(); it != itE; ++it )
{
Point p = *it;
float v = sqrt( d2( p ) );
m = std::max( v, m );
}
GradientColorMap<float> cmap_grad( 0, m );
cmap_grad.addColor( Color( 255, 255, 255 ) );
cmap_grad.addColor( Color( 255, 255, 0 ) );
cmap_grad.addColor( Color( 255, 0, 0 ) );
cmap_grad.addColor( Color( 0, 255, 0 ) );
cmap_grad.addColor( Color( 0, 0, 255 ) );
cmap_grad.addColor( Color( 0, 0, 0 ) );
QApplication application(argc,argv);
Viewer3D<> viewer;
viewer.show();
//board << SetMode( d2.domain().className(), "Paving" );
for ( typename Domain::ConstIterator it = d2.domain().begin(),
itE = d2.domain().end(); it != itE; ++it )
{
Point p = *it;
float v = sqrt( d2( p ) );
v = std::min( (float)m, std::max( v, 0.0f ) );
viewer << CustomColors3D(Color(cmap_grad(v).red(), cmap_grad(v).green(), cmap_grad(v).blue(), 120), Color(cmap_grad(v).red(), cmap_grad(v).green(), cmap_grad(v).blue(),120) )
<< p;
RealVector grad = delta.projection( p );
// / ( 1.1 - ( (double)img( *it ) ) / 255.0 ) ;
viewer.addLine( p, p+grad );
}
std::cout << endl;
viewer << Viewer3D<>::updateDisplay;
application.exec();
return 0;
}
int main( int argc, char** argv )
{
// parse command line ----------------------------------------------
po::options_description general_opt("Allowed options are: ");
general_opt.add_options()
("help,h", "display this message")
("input,i", po::value<std::vector<string> >()->multitoken(), "off files (.off), or OFS file (.ofs) " )
("scaleX,x", po::value<float>()->default_value(1.0), "set the scale value in the X direction (default 1.0)" )
("scaleY,y", po::value<float>()->default_value(1.0), "set the scale value in the Y direction (default 1.0)" )
("scaleZ,z", po:: value<float>()->default_value(1.0), "set the scale value in the Z direction (default 1.0)")
("minLineWidth,w", po:: value<float>()->default_value(1.5), "set the min line width of the mesh faces (default 1.5)")
("customColorMesh",po::value<std::vector<unsigned int> >()->multitoken(), "set the R, G, B, A components of the colors of the mesh faces and eventually the color R, G, B, A of the mesh edge lines (set by default to black). " )
("customColorSDP",po::value<std::vector<unsigned int> >()->multitoken(), "set the R, G, B, A components of the colors of the sdp view" )
("displayVectorField,f",po::value<std::string>(), "display a vector field from a simple sdp file (two points per line)" )
("vectorFieldIndex",po::value<std::vector<unsigned int> >()->multitoken(), "specify special indices for the two point coordinates (instead usinf the default indices: 0 1, 2, 3, 4, 5)" )
("customLineColor",po::value<std::vector<unsigned int> >()->multitoken(), "set the R, G, B components of the colors of the lines displayed from the --displayVectorField option (red by default). " )
("displaySDP,s", po::value<std::string>(), "Add the display of a set of discrete points as ball of radius 0.5.")
("SDPradius", po::value<double>()->default_value(0.5), "change the ball radius to display a set of discrete points (used with displaySDP option)")
("invertNormal,n", "threshold min to define binary shape" )
("drawVertex,v", "draw the vertex of the mesh" );
bool parseOK=true;
po::variables_map vm;
try {
po::store(po::parse_command_line(argc, argv, general_opt), vm);
} catch(const std::exception& ex) {
parseOK=false;
trace.info()<< "Error checking program options: "<< ex.what()<< endl;
}
po::notify(vm);
if( !parseOK || vm.count("help")||argc<=1)
{
std::cout << "Usage: " << argv[0] << " [input]\n"
<< "Display OFF mesh file by using QGLviewer"
<< general_opt << "\n";
return 0;
}
if(! vm.count("input"))
{
trace.error() << " The file name was defined" << endl;
return 0;
}
std::vector<std::string> inputFilenameVect = vm["input"].as<std::vector<std::string > >();
float sx = vm["scaleX"].as<float>();
float sy = vm["scaleY"].as<float>();
float sz = vm["scaleZ"].as<float>();
unsigned int meshColorR = 240;
unsigned int meshColorG = 240;
unsigned int meshColorB = 240;
unsigned int meshColorA = 255;
unsigned int meshColorRLine = 0;
unsigned int meshColorGLine = 0;
unsigned int meshColorBLine = 0;
unsigned int meshColorALine = 255;
unsigned int sdpColorR = 240;
unsigned int sdpColorG = 240;
unsigned int sdpColorB = 240;
unsigned int sdpColorA = 255;
bool displayVectorField = vm.count("displayVectorField");
std::vector<unsigned int> vectFieldIndices = {0,1,2,3,4,5};
if (displayVectorField) {
if(vm.count("vectorFieldIndex")) {
vectFieldIndices = vm["vectorFieldIndex"].as<std::vector<unsigned int> >();
if (vectFieldIndices.size() != 6) {
trace.warning() << "you should specify indices for each of the 6 fields of the two coordinates." << std::endl;
vectFieldIndices = {0,1,2,3,4,5};
}
}
}
float lineWidth = vm["minLineWidth"].as<float>();
DGtal::Color vFieldLineColor = DGtal::Color::Red;
if(vm.count("customLineColor")) {
std::vector<unsigned int > vectCol = vm["customLineColor"].as<std::vector<unsigned int> >();
if(vectCol.size()!=3 ) {
trace.error() << "colors specification should contain R,G,B values (using default red)."<< std::endl;
}
vFieldLineColor.setRGBi(vectCol[0], vectCol[1], vectCol[2], 255);
}
if(vm.count("customColorMesh")) {
std::vector<unsigned int > vectCol = vm["customColorMesh"].as<std::vector<unsigned int> >();
if(vectCol.size()!=4 && vectCol.size()!=8 ) {
trace.error() << "colors specification should contain R,G,B and Alpha values"<< std::endl;
}
meshColorR = vectCol[0];
meshColorG = vectCol[1];
meshColorB = vectCol[2];
meshColorA = vectCol[3];
if(vectCol.size() == 8) {
meshColorRLine = vectCol[4];
meshColorGLine = vectCol[5];
meshColorBLine = vectCol[6];
meshColorALine = vectCol[7];
}
}
if(vm.count("customColorSDP")) {
std::vector<unsigned int > vectCol = vm["customColorSDP"].as<std::vector<unsigned int> >();
if(vectCol.size()!=4) {
trace.error() << "colors specification should contain R,G,B and Alpha values"<< std::endl;
}
sdpColorR = vectCol[0];
sdpColorG = vectCol[1];
sdpColorB = vectCol[2];
sdpColorA = vectCol[3];
}
QApplication application(argc,argv);
Viewer3D<> viewer;
std::stringstream title;
title << "Simple Mesh Viewer: " << inputFilenameVect[0];
viewer.setWindowTitle(title.str().c_str());
viewer.show();
viewer.myGLLineMinWidth = lineWidth;
viewer.setGLScale(sx, sy, sz);
bool invertNormal= vm.count("invertNormal");
double ballRadius = vm["SDPradius"].as<double>();
trace.info() << "Importing mesh... ";
std::vector<Mesh<DGtal::Z3i::RealPoint> > vectMesh;
for(unsigned int i = 0; i< inputFilenameVect.size(); i++) {
Mesh<DGtal::Z3i::RealPoint> aMesh(!vm.count("customColorMesh"));
aMesh << inputFilenameVect[i];
vectMesh.push_back(aMesh);
}
bool import = vectMesh.size()==inputFilenameVect.size();
if(!import) {
trace.info() << "File import failed. " << std::endl;
return 0;
}
trace.info() << "[done]. "<< std::endl;
if(vm.count("displaySDP")) {
std::string filenameSDP = vm["displaySDP"].as<std::string>();
vector<Z3i::RealPoint> vectPoints;
vectPoints = PointListReader<Z3i::RealPoint>::getPointsFromFile(filenameSDP);
viewer << CustomColors3D(Color(sdpColorR, sdpColorG, sdpColorB, sdpColorA),
Color(sdpColorR, sdpColorG, sdpColorB, sdpColorA));
for(unsigned int i=0; i< vectPoints.size(); i++) {
viewer.addBall(vectPoints.at(i), ballRadius);
}
}
if(invertNormal) {
for(unsigned int i=0; i<vectMesh.size(); i++) {
vectMesh[i].invertVertexFaceOrder();
}
}
viewer << CustomColors3D(Color(meshColorRLine, meshColorGLine, meshColorBLine, meshColorALine),
Color(meshColorR, meshColorG, meshColorB, meshColorA));
for(unsigned int i=0; i<vectMesh.size(); i++) {
viewer << vectMesh[i];
}
if(vm.count("drawVertex")) {
for(unsigned int i=0; i<vectMesh.size(); i++) {
for( Mesh<DGtal::Z3i::RealPoint>::VertexStorage::const_iterator it = vectMesh[i].vertexBegin();
it!=vectMesh[i].vertexEnd(); ++it) {
DGtal::Z3i::Point pt;
pt[0]=(*it)[0];
pt[1]=(*it)[1];
pt[2]=(*it)[2];
viewer << pt;
}
}
}
if (displayVectorField) {
std::vector<unsigned int > vectFieldIndices1 = {vectFieldIndices[0],vectFieldIndices[1], vectFieldIndices[2]};
std::vector<unsigned int > vectFieldIndices2 = {vectFieldIndices[3],vectFieldIndices[4], vectFieldIndices[5]};
std::vector<DGtal::Z3i::RealPoint> vectPt1 = PointListReader<DGtal::Z3i::RealPoint>::getPointsFromFile(vm["displayVectorField"].as<std::string>(), vectFieldIndices1);
std::vector<DGtal::Z3i::RealPoint> vectPt2 = PointListReader<DGtal::Z3i::RealPoint>::getPointsFromFile(vm["displayVectorField"].as<std::string>(), vectFieldIndices2);
viewer.createNewLineList();
for (unsigned int i = 0; i < vectPt1.size(); i++) {
viewer.setLineColor(vFieldLineColor);
viewer.addLine(vectPt1[i], vectPt2[i]);
}
}
viewer << Viewer3D<>::updateDisplay;
return application.exec();
}
void displayAxes( Viewer3D<space, kspace> & viewer,
const Point & lowerBound, const Point & upperBound,
const std::string & mode )
{
RealPoint p0( (double)lowerBound[ 0 ]-0.5,
(double)lowerBound[ 1 ]-0.5,
(double)lowerBound[ 2 ]-0.5 );
RealPoint p1( (double)upperBound[ 0 ]-0.5,
(double)upperBound[ 1 ]-0.5,
(double)upperBound[ 2 ]-0.5 );
if ( ( mode == "WIRED" ) || ( mode == "COLORED" ) )
{
viewer.setLineColor(AXIS_COLOR);
viewer.addLine( DGtal::Z3i::RealPoint(p0[ 0 ], p0[ 1 ], p0[ 2 ]),
DGtal::Z3i::RealPoint(p1[ 0 ], p0[ 1 ], p0[ 2 ]), AXIS_LINESIZE );
viewer.addLine( DGtal::Z3i::RealPoint(p0[ 0 ], p0[ 1 ], p0[ 2 ]),
DGtal::Z3i::RealPoint(p0[ 0 ], p1[ 1 ], p0[ 2 ]), AXIS_LINESIZE );
viewer.addLine( DGtal::Z3i::RealPoint(p0[ 0 ], p0[ 1 ], p0[ 2 ]),
DGtal::Z3i::RealPoint(p0[ 0 ], p0[ 1 ], p1[ 2 ]), AXIS_LINESIZE );
viewer.addLine( DGtal::Z3i::RealPoint(p1[ 0 ], p0[ 1 ], p0[ 2 ]),
DGtal::Z3i::RealPoint(p1[ 0 ], p1[ 1 ], p0[ 2 ]), AXIS_LINESIZE );
viewer.addLine( DGtal::Z3i::RealPoint(p1[ 0 ], p0[ 1 ], p0[ 2 ]),
DGtal::Z3i::RealPoint(p1[ 0 ], p0[ 1 ], p1[ 2 ]), AXIS_LINESIZE );
viewer.addLine( DGtal::Z3i::RealPoint(p0[ 0 ], p1[ 1 ], p0[ 2 ]),
DGtal::Z3i::RealPoint(p1[ 0 ], p1[ 1 ], p0[ 2 ]), AXIS_LINESIZE );
viewer.addLine( DGtal::Z3i::RealPoint(p0[ 0 ], p1[ 1 ], p0[ 2 ]),
DGtal::Z3i::RealPoint(p0[ 0 ], p1[ 1 ], p1[ 2 ]), AXIS_LINESIZE );
viewer.addLine( DGtal::Z3i::RealPoint(p0[ 0 ], p0[ 1 ], p1[ 2 ]),
DGtal::Z3i::RealPoint(p1[ 0 ], p0[ 1 ], p1[ 2 ]), AXIS_LINESIZE );
viewer.addLine( DGtal::Z3i::RealPoint(p0[ 0 ], p0[ 1 ], p1[ 2 ]),
DGtal::Z3i::RealPoint(p0[ 0 ], p1[ 1 ], p1[ 2 ]), AXIS_LINESIZE );
viewer.addLine( DGtal::Z3i::RealPoint(p1[ 0 ], p1[ 1 ], p0[ 2 ]),
DGtal::Z3i::RealPoint(p1[ 0 ], p1[ 1 ], p1[ 2 ]), AXIS_LINESIZE );
viewer.addLine( DGtal::Z3i::RealPoint(p1[ 0 ], p0[ 1 ], p1[ 2 ]),
DGtal::Z3i::RealPoint(p1[ 0 ], p1[ 1 ], p1[ 2 ]), AXIS_LINESIZE );
viewer.addLine( DGtal::Z3i::RealPoint(p0[ 0 ], p1[ 1 ], p1[ 2 ]),
DGtal::Z3i::RealPoint(p1[ 0 ], p1[ 1 ], p1[ 2 ]), AXIS_LINESIZE );
}
if ( mode == "COLORED" )
{
viewer.setFillColor(XY_COLOR);
viewer.addQuad(DGtal::Z3i::RealPoint(p1[ 0 ], p1[ 1 ], p1[ 2 ]),
DGtal::Z3i::RealPoint(p1[ 0 ], p0[ 1 ], p1[ 2 ]),
DGtal::Z3i::RealPoint(p0[ 0 ], p0[ 1 ], p1[ 2 ]),
DGtal::Z3i::RealPoint(p0[ 0 ], p1[ 1 ], p1[ 2 ]) );
viewer.setFillColor(XZ_COLOR);
viewer.addQuad(DGtal::Z3i::RealPoint(p1[ 0 ], p1[ 1 ], p1[ 2 ]),
DGtal::Z3i::RealPoint(p0[ 0 ], p1[ 1 ], p1[ 2 ]),
DGtal::Z3i::RealPoint(p0[ 0 ], p1[ 1 ], p0[ 2 ]),
DGtal::Z3i::RealPoint(p1[ 0 ], p1[ 1 ], p0[ 2 ]));
viewer.setFillColor(YZ_COLOR);
viewer.addQuad(DGtal::Z3i::RealPoint(p1[ 0 ], p1[ 1 ], p1[ 2 ]),
DGtal::Z3i::RealPoint(p1[ 0 ], p0[ 1 ], p1[ 2 ]),
DGtal::Z3i::RealPoint(p1[ 0 ], p0[ 1 ], p0[ 2 ]),
DGtal::Z3i::RealPoint(p1[ 0 ], p1[ 1 ], p0[ 2 ]));
}
}
