~ubuntu-branches/ubuntu/trusty/3depict/trusty

DrawGLText::DrawGLText(std::string fontFile, unsigned int mode) : curFontMode(mode), origin(0.0f,0.0f,0.0f), r(0.0),g(0.0),b(0.0),a(1.0), up(0.0f,1.0f,0.0f), textDir(1.0f,0.0f,0.0f), readDir(0.0f,0.0f,1.0f), isOK(true),ensureReadFromNorm(true)

699

{

700

fontString = fontFile;

701

702

font=0;

703

switch(mode)

704

{

705

case FTGL_BITMAP:

706

font = new FTGLBitmapFont(fontFile.c_str());

707

break;

708

case FTGL_PIXMAP:

709

font = new FTGLPixmapFont(fontFile.c_str());

710

break;

711

case FTGL_OUTLINE:

712

font = new FTGLOutlineFont(fontFile.c_str());

713

break;

714

case FTGL_POLYGON:

715

font = new FTGLPolygonFont(fontFile.c_str());

716

break;

717

case FTGL_EXTRUDE:

718

font = new FTGLExtrdFont(fontFile.c_str());

719

break;

720

case FTGL_TEXTURE:

721

font = new FTGLTextureFont(fontFile.c_str());

722

break;

723

default:

724

//Don't do this. Use valid font numbers

725

ASSERT(false);

726

font=0;

727

}

728

729

//In case of allocation failure or invalid font num

730

if(!font || font->Error())

731

{

732

isOK=false;

733

return;

734

}

735

736

//Try to make it 100 point

737

font->FaceSize(5);

738

font->Depth(20);

739

740

//Use unicode

741

font->CharMap(ft_encoding_unicode);

742

743

alignMode = DRAWTEXT_ALIGN_LEFT;

744

}

745

746

void DrawGLText::draw() const

747

{

748

if(!isOK)

749

return;

750

751

//Translate the drawing position to the origin

752

Point3D offsetVec=textDir;

753

float advance;

754

float halfHeight;

755

756

FTBBox box;

757

box=font->BBox(strText.c_str());

758

advance=box.Upper().X()-box.Lower().X();

759

760

halfHeight=box.Upper().Y()-box.Lower().Y();

761

halfHeight/=2.0f;

762

763

switch(alignMode)

764

{

765

case DRAWTEXT_ALIGN_LEFT:

766

break;

767

case DRAWTEXT_ALIGN_CENTRE:

768

offsetVec=offsetVec*advance/2.0f;

769

break;

770

case DRAWTEXT_ALIGN_RIGHT:

771

offsetVec=offsetVec*advance;

772

break;

773

default:

774

ASSERT(false);

775

}

776

777

778

glPushMatrix();

779

780

781

glPushAttrib(GL_CULL_FACE);

782

783

glDisable(GL_CULL_FACE);

784

if(curFontMode !=FTGL_BITMAP)

785

{

786

offsetVec=origin-offsetVec;

787

glTranslatef(offsetVec[0],offsetVec[1],offsetVec[2]);

788

789

//Rotate such that the new X-Y plane is set to the

790

//desired text orientation. (ie. we want to draw the text in the

791

//specified combination of updir-textdir, rather than in the X-y plane)

792

793

//---

794

//Textdir and updir MUST be normal to one another

795

ASSERT(textDir.dotProd(up) < sqrtf(std::numeric_limits<float>::epsilon()));

796

797

//rotate around textdir cross X, if the two are not the same

798

Point3D rotateAxis;

799

Point3D newUp=up;

800

float angle=textDir.angle(Point3D(1,0,0) );

801

if(angle > sqrtf(std::numeric_limits<float>::epsilon()))

802

{

803

rotateAxis = textDir.crossProd(Point3D(-1,0,0));

804

rotateAxis.normalise();

805

806

Point3f tmp,axis;

807

tmp.fx=up[0];

808

tmp.fy=up[1];

809

tmp.fz=up[2];

810

811

axis.fx=rotateAxis[0];

812

axis.fy=rotateAxis[1];

813

axis.fz=rotateAxis[2];

814

815

816

glRotatef(angle*180.0f/M_PI,rotateAxis[0],rotateAxis[1],rotateAxis[2]);

817

quat_rot(&tmp,&axis,angle); //angle is in radiians

818

819

newUp[0]=tmp.fx;

820

newUp[1]=tmp.fy;

821

newUp[2]=tmp.fz;

822

}

823

824

//rotate new up direction into y around x axis

825

angle = newUp.angle(Point3D(0,1,0));

826

if(angle > sqrtf(std::numeric_limits<float>::epsilon()) &&

827

fabs(angle - M_PI) > sqrtf(std::numeric_limits<float>::epsilon()))

828

{

829

rotateAxis = newUp.crossProd(Point3D(0,-1,0));

830

rotateAxis.normalise();

831

glRotatef(angle*180.0f/M_PI,rotateAxis[0],rotateAxis[1],rotateAxis[2]);

832

}

833

834

//Ensure that the text is not back-culled (i.e. if the

835

//text normal is pointing away from the camera, it does not

836

//get drawn). Here we have to flip the normal, by spinning the

837

//text by 180 around its up direction (which has been modified

838

//by above code to coincide with the y axis.

839

if(curCamera)

840

{

841

//This is not *quite* right in perspective mode

842

//but is right in orthogonal

843

844

Point3D textNormal,camVec;

845

textNormal = up.crossProd(textDir);

846

textNormal.normalise();

847

848

camVec = origin - curCamera->getOrigin();

849

850

//ensure the camera is not sitting on top of the text.

851

if(camVec.sqrMag() > std::numeric_limits<float>::epsilon())

852

{

853

854

camVec.normalise();

855

856

if(camVec.dotProd(textNormal) < 0)

857

{

858

//move halfway along text, noting that

859

//the text direction is now the x-axis

860

glTranslatef(advance/2.0f,halfHeight,0);

861

//spin text around its up direction 180 degrees

862

glRotatef(180,0,1,0);

863

//restore back to original position

864

glTranslatef(-advance/2.0f,-halfHeight,0);

865

}

866

867

camVec=curCamera->getUpDirection();

868

if(camVec.dotProd(up) < 0)

869

{

870

//move halfway along text, noting that

871

//the text direction is now the x-axis

872

glTranslatef(advance/2.0f,halfHeight,0);

873

//spin text around its front direction 180 degrees

874

//no need to trnaslate as text sits at its baseline

875

glRotatef(180,0,0,1);

876

//move halfway along text, noting that

877

//the text direction is now the x-axis

878

glTranslatef(-advance/2.0f,-halfHeight,0);

879

}

880

881

}

882

883

884

}

885

886

}

887

else

888

{

889

//FIXME: The text ends up in a wierd location

890

//2D coordinate storage for bitmap text

891

double xWin,yWin,zWin;

892

//Compute the 2D coordinates

893

double model_view[16];

894

glGetDoublev(GL_MODELVIEW_MATRIX, model_view);

895

896

double projection[16];

897

glGetDoublev(GL_PROJECTION_MATRIX, projection);

898

899

int viewport[4];

900

glGetIntegerv(GL_VIEWPORT, viewport);

901

902

//Apply the openGL coordinate transformation pipleine to the

903

//specified coords

904

gluProject(offsetVec[0],offsetVec[1],offsetVec[2]

905

,model_view,projection,viewport,

906

&xWin,&yWin,&zWin);

907

908

glRasterPos3f(xWin,yWin,zWin);

909

910

}

911

//---

912

913

914

glColor4f(r,g,b,a);

915

916

//Draw text

917

if(curFontMode == FTGL_TEXTURE)

918

{

919

glPushAttrib(GL_ENABLE_BIT);

920

glEnable(GL_TEXTURE_2D);

921

922

font->Render(strText.c_str());

923

glPopAttrib();

924

}

925

else

926

font->Render(strText.c_str());

927

928

glPopAttrib();

929

930

glPopMatrix();

931

}

932

933

DrawGLText::~DrawGLText()

934

{

935

if(font)

936

delete font;

937

}

938

939

void DrawGLText::setColour(float rnew, float gnew, float bnew, float anew)

940

{

941

r=rnew;

942

g=gnew;

943

b=bnew;

944

a=anew;

945

}

946

947

void DrawGLText::getBoundingBox(BoundCube &b) const

948

{

949

950

if(isOK)

951

{

952

float minX,minY,minZ;

953

float maxX,maxY,maxZ;

954

font->BBox(strText.c_str(),minX,minY,minZ,maxX,maxY,maxZ);

955

b.setBounds(minX+origin[0],minY+origin[1],minZ+origin[2],

956

maxX+origin[0],maxY+origin[1],maxZ+origin[2]);

957

}

958

else

959

b.setInverseLimits();

960

961

}

962

963

void DrawGLText::setAlignment(unsigned int newMode)

964

{

965

ASSERT(newMode < DRAWTEXT_ALIGN_ENUM_END);

966

alignMode=newMode;

967

}

968

969

void DrawGLText::recomputeParams(const vector<Point3D> &vecs,

970

const vector<float> &scalars, unsigned int mode)

971

{

972

switch(mode)

973

{

974

case DRAW_TEXT_BIND_ORIGIN:

975

ASSERT(vecs.size() ==1 && scalars.size() ==0);

976

origin=vecs[0];

977

break;

978

default:

979

ASSERT(false);

980

}

981

}

982

983

DrawRectPrism::DrawRectPrism()

984

{

985

r=g=b=a=1.0f;

986

drawMode=DRAW_WIREFRAME;

987

lineWidth=1.0f;

988

}

989

DrawRectPrism::~DrawRectPrism()

990

{

991

}

992

993

void DrawRectPrism::getBoundingBox(BoundCube &b) const

994

{

995

b.setBounds(pMin[0],pMin[1],pMin[2],

996

pMax[0],pMax[1],pMax[2]);

997

}

998

999

void DrawRectPrism::draw() const

1000

{

1001

ASSERT(r <=1.0f && g<=1.0f && b <=1.0f && a <=1.0f);

1002

ASSERT(r >=0.0f && g>=0.0f && b >=0.0f && a >=0.0f);

1003

1004

if(!active)

1005

return;

1006

1007

switch(drawMode)

1008

{

1009

case DRAW_WIREFRAME:

1010

{

1011

glLineWidth(lineWidth);

1012

drawBox(pMin,pMax,r,g,b,a);

1013

break;

1014

}

1015

case DRAW_FLAT:

1016

{

1017

glBegin(GL_QUADS);

1018

glColor4f(r,g,b,a);

1019

1020

glNormal3f(0,0,-1);

1021

//Along the bottom

1022

glVertex3f(pMin[0],pMin[1],pMin[2]);

1023

glVertex3f(pMin[0],pMax[1],pMin[2]);

1024

glVertex3f(pMax[0],pMax[1],pMin[2]);

1025

glVertex3f(pMax[0],pMin[1],pMin[2]);

1026

//Up the side

1027

glNormal3f(1,0,0);

1028

glVertex3f(pMax[0],pMax[1],pMax[2]);

1029

glVertex3f(pMax[0],pMin[1],pMax[2]);

1030

glVertex3f(pMax[0],pMin[1],pMin[2]);

1031

glVertex3f(pMax[0],pMax[1],pMin[2]);

1032

//Over the top

1033

glNormal3f(0,0,1);

1034

glVertex3f(pMax[0],pMin[1],pMax[2]);

1035

glVertex3f(pMax[0],pMax[1],pMax[2]);

1036

glVertex3f(pMin[0],pMax[1],pMax[2]);

1037

glVertex3f(pMin[0],pMin[1],pMax[2]);

1038

1039

//and back down

1040

glNormal3f(-1,0,0);

1041

glVertex3f(pMin[0],pMax[1],pMin[2]);

1042

glVertex3f(pMin[0],pMin[1],pMin[2]);

1043

glVertex3f(pMin[0],pMin[1],pMax[2]);

1044

glVertex3f(pMin[0],pMax[1],pMax[2]);

1045

1046

//Now the other two sides

1047

glNormal3f(0,-1,0);

1048

glVertex3f(pMax[0],pMin[1],pMax[2]);

1049

glVertex3f(pMin[0],pMin[1],pMax[2]);

1050

glVertex3f(pMin[0],pMin[1],pMin[2]);

1051

glVertex3f(pMax[0],pMin[1],pMin[2]);

1052

1053

glNormal3f(0,1,0);

1054

glVertex3f(pMax[0],pMax[1],pMax[2]);

1055

glVertex3f(pMax[0],pMax[1],pMin[2]);

1056

glVertex3f(pMin[0],pMax[1],pMin[2]);

1057

glVertex3f(pMin[0],pMax[1],pMax[2]);

1058

1059

glEnd();

1060

1061

break;

1062

1063

}

1064

default:

1065

ASSERT(false);

1066

}

1067

1068

1069

}

1070

1071

void DrawRectPrism::setAxisAligned( const Point3D &p1, const Point3D &p2)

1072

{

1073

for(unsigned int ui=0; ui<3; ui++)

1074

{

1075

pMin[ui]=std::min(p1[ui],p2[ui]);

1076

pMax[ui]=std::max(p1[ui],p2[ui]);

1077

}

1078

1079

}

1080

1081

void DrawRectPrism::setAxisAligned( const BoundCube &b)

1082

{

1083

b.getBounds(pMin,pMax);

1084

}

1085

1086

void DrawRectPrism::setColour(float rnew, float gnew, float bnew, float anew)

1087

{

1088

r=rnew;

1089

g=gnew;

1090

b=bnew;

1091

a=anew;

1092

}

1093

1094

void DrawRectPrism::setLineWidth(float newLineWidth)

1095

{

1096

ASSERT(newLineWidth > 0.0f);

1097

lineWidth=newLineWidth;

1098

}

1099

1100

void DrawRectPrism::recomputeParams(const vector<Point3D> &vecs,

1101

const vector<float> &scalars, unsigned int mode)

1102

{

1103

switch(mode)

1104

{

1105

case DRAW_RECT_BIND_TRANSLATE:

1106

{

1107

ASSERT(vecs.size() ==1);

1108

Point3D delta;

1109

delta = (pMax - pMin)*0.5;

1110

//Object has been translated

1111

pMin = vecs[0]-delta;

1112

pMax = vecs[0]+delta;

1113

break;

1114

}

1115

case DRAW_RECT_BIND_CORNER_MOVE:

1116

{

1117

ASSERT(vecs.size() ==1);

1118

//Delta has changed, but origin shoudl stay the same

1119

Point3D mean, corner;

1120

mean = (pMin + pMax)*0.5;

1121

1122

//Prevent negative offset values, otherwise we can

1123

//get inside out boxes

1124

corner=vecs[0];

1125

for(unsigned int ui=0;ui<3;ui++)

1126

corner[ui]= fabs(corner[ui]);

1127

1128

pMin = mean-corner;

1129

pMax = mean+corner;

1130

break;

1131

}

1132

default:

1133

ASSERT(false);

1134

}

1135

}

1136

1137

DrawTexturedQuadOverlay::DrawTexturedQuadOverlay()

1138

{

1139

texPool=0;

1140

}

1141

1142

DrawTexturedQuadOverlay::~DrawTexturedQuadOverlay()

1143

{

1144

textureOK=false;

1145

}

1146

1147

void DrawTexturedQuadOverlay::setSize(float s)

1148

{

1149

length=s;

1150

}

1151

1152

1153

void DrawTexturedQuadOverlay::draw() const

1154

{

1155

if(!textureOK)

1156

return;

1157

1158

ASSERT(glIsTexture(textureId));

1159

1160

glMatrixMode(GL_PROJECTION);

1161

glPushMatrix();

1162

glLoadIdentity();

1163

gluOrtho2D(0, winX, winY, 0);

1164

1165

glMatrixMode(GL_MODELVIEW);

1166

glPushMatrix();

1167

glLoadIdentity();

1168

1169

glEnable(GL_TEXTURE_2D);

1170

glBindTexture(GL_TEXTURE_2D,textureId);

1171

1172

// Draw overlay quad

1173

glColor3f(1.0f,1.0f,1.0f);

1174

glBegin(GL_QUADS);

1175

glTexCoord2f(0.0f,0.0f);

1176

glVertex3f(position[0]-length/2.0,position[1]-length/2.0,0.0);

1177

glTexCoord2f(0.0f,1.0f);

1178

glVertex3f(position[0]-length/2.0,position[1]+length/2.0,0.0);

1179

glTexCoord2f(1.0f,1.0f);

1180

glVertex3f(position[0]+length/2.0,position[1]+length/2.0,0.0);

1181

glTexCoord2f(1.0f,0.0f);

1182

glVertex3f(position[0]+length/2.0,position[1]-length/2.0,0.0);

1183

glEnd();

1184

1185

glDisable(GL_TEXTURE_2D);

1186

/* draw stuff */

1187

1188

glPopMatrix(); //Pop modelview matrix

1189

1190

glMatrixMode(GL_PROJECTION);

1191

glPopMatrix();

1192

1193

glMatrixMode(GL_MODELVIEW);

1194

}

1195

1196

1197

bool DrawTexturedQuadOverlay::setTexture(const char *textureFile)

1198

{

1199

ASSERT(texPool);

1200

unsigned int dummy;

1201

1202

textureOK= texPool->openTexture(textureFile,textureId,dummy);

1203

return textureOK;

1204

}

1205

1206

void DrawTexturedQuadOverlay::getBoundingBox(BoundCube &b) const

1207

{

1208

b.setInvalid();

1209

}

1210

1211

1212

DrawColourBarOverlay::DrawColourBarOverlay()

1213

{

1214

a=1.0;

1215

string f;

1216

f=getDefaultFontFile();

1217

font = new FTGLPolygonFont(f.c_str());

1218

};

1219

1220

1221

void DrawColourBarOverlay::draw() const

1222

{

1223

//Draw quads

1224

float elemHeight;

1225

//80% of bar width is for the actual colour bar itself.

1226

float barWidth=0.8*width;

1227

elemHeight=height/(float)rgb.size();

1228

glBegin(GL_QUADS);

1229

for(unsigned int ui=0;ui<rgb.size();ui++)

1230

{

1231

//Set the quad colour for bar element

1232

glColor4f(rgb[rgb.size()-(ui+1)].v[0],

1233

rgb[rgb.size()-(ui+1)].v[1],

1234

rgb[rgb.size()-(ui+1)].v[2],1.0);

1235

1236

//draw this quad (bar element)

1237

glVertex3f(tlX,tlY+(float)ui*elemHeight,0);

1238

glVertex3f(tlX,tlY+(float)(ui+1)*elemHeight,0);

1239

glVertex3f(tlX+barWidth,tlY+(float)(ui+1)*elemHeight,0);

1240

glVertex3f(tlX+barWidth,tlY+(float)(ui)*elemHeight,0);

1241

}

1242

1243

glEnd();

1244

1245

//Draw ticks on colour bar

1246

glBegin(GL_LINES);

1247

glColor4f(1.0,1.0,1.0f,1.0f);

1248

//Top tick

1249

glVertex3f(tlX,tlY,0);

1250

glVertex3f(tlX+width,tlY,0);

1251

//Bottom tick

1252

glVertex3f(tlX,tlY+height,0);

1253

glVertex3f(tlX+width,tlY+height,0);

1254

glEnd();

1255

1256

1257

1258

1259

if(!font || font->Error())

1260

{

1261

#ifdef DEBUG

1262

std::cerr << "Ah bugger. No font!" << std::endl;

1263

#endif

1264

return;

1265

}

1266

1267

1268

1269

//FTGL units are a pain; The devs could not decide

1270

//whether to implement them in opengl coords or real coords

1271

//so they did neither, and implemented them in "points".

1272

//here we assume that we can transform 1 ftgl unit

1273

//to 1 opengl unit by inversion

1274

const float FTGL_DEFAULT_UNIT_SCALE=1.0/72.0;

1275

1276

glColor3f(1.0f,1.0f,1.0f);

1277

font->FaceSize(3);

1278

glDisable(GL_CULL_FACE);

1279

glPushMatrix();

1280

glTranslatef(tlX+width,tlY,0);

1281

string s;

1282

stream_cast(s,max);

1283

//Note negative sign to flip from y-down screen (opengl) to text dir

1284

//(y up)

1285

glScaled(FTGL_DEFAULT_UNIT_SCALE,

1286

-FTGL_DEFAULT_UNIT_SCALE,FTGL_DEFAULT_UNIT_SCALE);

1287

font->Render(s.c_str());

1288

glPopMatrix();

1289

1290

glPushMatrix();

1291

glTranslatef(tlX+width,tlY+height,0);

1292

stream_cast(s,min);

1293

//Note negative sign to flip from y-down screen (opengl) to text dir

1294

//(y up)

1295

glScaled(FTGL_DEFAULT_UNIT_SCALE,

1296

-FTGL_DEFAULT_UNIT_SCALE,FTGL_DEFAULT_UNIT_SCALE);

1297

font->Render(s.c_str());

1298

glPopMatrix();

1299

glEnable(GL_CULL_FACE);

1300

1301

1302

1303

}

1304

1305

void DrawColourBarOverlay::setColourVec(const vector<float> &r,

1306

const vector<float> &g,

1307

const vector<float> &b)

1308

{

1309

ASSERT(r.size() == g.size());

1310

ASSERT(g.size() == b.size());

1311

rgb.resize(r.size());

1312

for(unsigned int ui=0;ui<r.size();ui++)

1313

{

1314

rgb[ui].v[0]=r[ui];

1315

rgb[ui].v[1]=g[ui];

1316

rgb[ui].v[2]=b[ui];

1317

}

1318

1319

1320

}

1321

1322

void DrawColourBarOverlay::getBoundingBox(BoundCube &b) const

1323

{

1324

b.setInvalid();

1325

}

1326

1327

1328

DrawField3D::DrawField3D() : alphaVal(0.2f), pointSize(1.0f), drawBoundBox(true),volumeGrid(false), volumeRenderMode(0), field(0)

1329

{

1330

boxColourR = boxColourG = boxColourB = boxColourA = 1.0f;

1331

ptsCacheOK=false;

1332

}

1333

1334

DrawField3D::~DrawField3D()

1335

{

1336

if(field)

1337

delete field;

1338

}

1339

1340

1341

void DrawField3D::getBoundingBox(BoundCube &b) const

1342

{

1343

ASSERT(field)

1344

b.setBounds(field->getMinBounds(),field->getMaxBounds());

1345

}

1346

1347

1348

void DrawField3D::setField(const Voxels<float> *newField)

1349

{

1350

field=newField;

1351

}

1352

1353

void DrawField3D::setRenderMode(unsigned int mode)

1354

{

1355

volumeRenderMode=mode;

1356

}

1357

1358

void DrawField3D::setColourMinMax()

1359

{

1360

colourMapBound[0]=field->min();

1361

colourMapBound[1]=field->max();

1362

1363

ASSERT(colourMapBound[0] <=colourMapBound[1]);

1364

}

1365

1366

1367

void DrawField3D::draw() const

1368

{

1369

if(alphaVal < sqrt(std::numeric_limits<float>::epsilon()))

1370

return;

1371

1372

ASSERT(field);

1373

1374

//Depend upon the render mode

1375

switch(volumeRenderMode)

1376

{

1377

case VOLUME_POINTS:

1378

{

1379

size_t fieldSizeX,fieldSizeY,fieldSizeZ;

1380

Point3D p;

1381

1382

field->getSize(fieldSizeX,fieldSizeY, fieldSizeZ);

1383

1384

Point3D delta;

1385

delta = field->getPitch();

1386

delta*=0.5;

1387

if(!ptsCacheOK)

1388

{

1389

ptsCache.clear();

1390

for(unsigned int uiX=0; uiX<fieldSizeX; uiX++)

1391

{

1392

for(unsigned int uiY=0; uiY<fieldSizeY; uiY++)

1393

{

1394

for(unsigned int uiZ=0; uiZ<fieldSizeZ; uiZ++)

1395

{

1396

float v;

1397

v=field->getData(uiX,uiY,uiZ);

1398

if(v > std::numeric_limits<float>::epsilon())

1399

{

1400

RGBThis rgb;

1401

//Set colour and point loc

1402

colourMapWrap(colourMapID,rgb.v,

1403

field->getData(uiX,uiY,uiZ),

1404

colourMapBound[0],colourMapBound[1]);

1405

1406

ptsCache.push_back(make_pair(field->getPoint(uiX,uiY,uiZ)+delta,rgb));

1407

}

1408

}

1409

}

1410

}

1411

1412

1413

ptsCacheOK=true;

1414

}

1415

1416

if(alphaVal < 1.0f)

1417

{

1418

//We need to generate some points, then sort them by distance

1419

//from eye (back to front), otherwise they will not blend properly

1420

std::vector<std::pair<float,unsigned int > > eyeDists;

1421

1422

Point3D camOrigin = curCamera->getOrigin();

1423

1424

eyeDists.resize(ptsCache.size());

1425

1426

//Set up an original index for the eye distances

1427

#pragma omp parallel for

1428

for(unsigned int ui=0;ui<ptsCache.size();ui++)

1429

{

1430

eyeDists[ui].first=ptsCache[ui].first.sqrDist(camOrigin);

1431

eyeDists[ui].second=ui;

1432

}

1433

1434

ComparePairFirstReverse cmp;

1435

std::sort(eyeDists.begin(),eyeDists.end(),cmp);

1436

1437

//render each element in the field as a point

1438

//the colour of the point is determined by its scalar value

1439

glDepthMask(GL_FALSE);

1440

glPointSize(pointSize);

1441

glBegin(GL_POINTS);

1442

for(unsigned int ui=0;ui<ptsCache.size();ui++)

1443

{

1444

unsigned int idx;

1445

idx=eyeDists[ui].second;

1446

//Tell openGL about it

1447

glColor4f(((float)(ptsCache[idx].second.v[0]))/255.0f,

1448

((float)(ptsCache[idx].second.v[1]))/255.0f,

1449

((float)(ptsCache[idx].second.v[2]))/255.0f,

1450

alphaVal);

1451

glVertex3f(ptsCache[idx].first[0],ptsCache[idx].first[1],ptsCache[idx].first[2]);

1452

}

1453

glEnd();

1454

glDepthMask(GL_TRUE);

1455

}

1456

else

1457

{

1458

for(unsigned int ui=0;ui<ptsCache.size();ui++)

1459

{

1460

//Tell openGL about it

1461

glColor4f(((float)(ptsCache[ui].second.v[0]))/255.0f,

1462

((float)(ptsCache[ui].second.v[1]))/255.0f,

1463

((float)(ptsCache[ui].second.v[2]))/255.0f,

1464

1.0f);

1465

glVertex3f(ptsCache[ui].first[0],ptsCache[ui].first[1],ptsCache[ui].first[2]);

1466

}

1467

}

1468

break;

1469

}

1470

1471

default:

1472

//Not implemented

1473

ASSERT(false);

1474

}

1475

1476

//Draw the bounding box as required

1477

if(drawBoundBox)

1478

{

1479

drawBox(field->getMinBounds(),field->getMaxBounds(),

1480

boxColourR, boxColourG,boxColourB,boxColourA);

1481

}

1482

//Draw the projections

1483

}

1484

1485

void DrawField3D::setAlpha(float newAlpha)

1486

{

1487

alphaVal=newAlpha;

1488

}

1489

1490

void DrawField3D::setPointSize(float size)

1491

{

1492

pointSize=size;

1493

}

1494

1495

void DrawField3D::setMapColours(unsigned int mapID)

1496

{

1497

ASSERT(mapID < NUM_COLOURMAPS);

1498

colourMapID= mapID;

1499

}

1500

1501

void DrawField3D::setBoxColours(float rNew, float gNew, float bNew, float aNew)

1502

{

1503

boxColourR = rNew;

1504

boxColourG = gNew;

1505

boxColourB = bNew;

1506

boxColourA = aNew;

1507

1508

}

1509

1510

1511

DrawIsoSurface::DrawIsoSurface()

1512

{

1513

cacheOK=false;

1514

drawMode=DRAW_SMOOTH;

1515

threshold=0.5;

1516

voxels=0;

1517

1518

r=0.5;

1519

g=0.5;

1520

b=0.5;

1521

a=1.0;

1522

}

1523

1524

DrawIsoSurface::~DrawIsoSurface()

1525

{

1526

if(voxels)

1527

delete voxels;

1528

}

1529

1530

1531

bool DrawIsoSurface::needsDepthSorting() const

1532

{

1533

return a< 1 && a > std::numeric_limits<float>::epsilon();

1534

}

1535

1536

void DrawIsoSurface::swapVoxels(Voxels<float> *f)

1537

{

1538

std::swap(f,voxels);

1539

cacheOK=false;

1540

mesh.clear();

1541

}

1542

1543

1544

void DrawIsoSurface::updateMesh() const

1545

{

1546

1547

mesh.clear();

1548

marchingCubes(*voxels, threshold,mesh);

1549

1550

cacheOK=true;

1551

1552

}

1553

1554

void DrawIsoSurface::getBoundingBox(BoundCube &b) const

1555

{

1556

if(voxels)

1557

{

1558

b.setBounds(voxels->getMinBounds(),

1559

voxels->getMaxBounds());

1560

}

1561

else

1562

b.setInverseLimits();

1563

}

1564

1565

1566

void DrawIsoSurface::draw() const

1567

{

1568

if(a< sqrt(std::numeric_limits<float>::epsilon()))

1569

return;

1570

1571

if(!cacheOK)

1572

{

1573

//Hmm, we don't have a cached copy of the isosurface mesh.

1574

//we will need to compute one, it would seem.

1575

updateMesh();

1576

}

1577

1578

1579

//This could be optimised by using triangle strips

1580

//rather than direct triangles.

1581

if(a < 1.0f)

1582

{

1583

//We need to sort them by distance

1584

//from eye (back to front), otherwise they will not blend properly

1585

std::vector<std::pair<float,unsigned int > > eyeDists;

1586

1587

Point3D camOrigin = curCamera->getOrigin();

1588

eyeDists.resize(mesh.size());

1589

1590

//Set up an original index for the eye distances

1591

#pragma omp parallel for shared(camOrigin)

1592

for(unsigned int ui=0;ui<mesh.size();ui++)

1593

{

1594

Point3D centroid;

1595

mesh[ui].getCentroid(centroid);

1596

1597

eyeDists[ui].first=centroid.sqrDist(camOrigin);

1598

eyeDists[ui].second=ui;

1599

}

1600

1601

ComparePairFirstReverse cmp;

1602

std::sort(eyeDists.begin(),eyeDists.end(),cmp);

1603

1604

1605

glDepthMask(GL_FALSE);

1606

glColor4f(r,g,b,a);

1607

glPushAttrib(GL_CULL_FACE);

1608

glDisable(GL_CULL_FACE);

1609

1610

glBegin(GL_TRIANGLES);

1611

for(unsigned int ui=0;ui<mesh.size();ui++)

1612

{

1613

unsigned int idx;

1614

idx=eyeDists[ui].second;

1615

glNormal3fv(mesh[idx].normal[0].getValueArr());

1616

glVertex3fv(mesh[idx].p[0].getValueArr());

1617

glNormal3fv(mesh[idx].normal[1].getValueArr());

1618

glVertex3fv(mesh[idx].p[1].getValueArr()),

1619

glNormal3fv(mesh[idx].normal[2].getValueArr());

1620

glVertex3fv(mesh[idx].p[2].getValueArr());

1621

}

1622

glEnd();

1623

1624

1625

glPopAttrib();

1626

glDepthMask(GL_TRUE);

1627

1628

}

1629

else

1630

{

1631

glColor4f(r,g,b,a);

1632

glPushAttrib(GL_CULL_FACE);

1633

glDisable(GL_CULL_FACE);

1634

glBegin(GL_TRIANGLES);

1635

for(unsigned int ui=0;ui<mesh.size();ui++)

1636

{

1637

glNormal3fv(mesh[ui].normal[0].getValueArr());

1638

glVertex3fv(mesh[ui].p[0].getValueArr());

1639

glNormal3fv(mesh[ui].normal[1].getValueArr());

1640

glVertex3fv(mesh[ui].p[1].getValueArr()),

1641

glNormal3fv(mesh[ui].normal[2].getValueArr());

1642

glVertex3fv(mesh[ui].p[2].getValueArr());

1643

}

1644

glEnd();

1645

glPopAttrib();

1646

}

1647

}

1648

1649

1650

1651

DrawAxis::DrawAxis()

1652

{

1653

}

1654

1655

DrawAxis::~DrawAxis()

1656

{

1657

}

1658

1659

void DrawAxis::setStyle(unsigned int s)

1660

{

1661

style=s;

1662

}

1663

1664

void DrawAxis::setSize(float s)

1665

{

1666

size=s;

1667

}

1668

1669

void DrawAxis::setPosition(const Point3D &p)

1670

{

1671

position=p;

1672

}

1673

1674

void DrawAxis::draw() const

1675

1676

{

1677

float halfSize=size/2.0f;

1678

glPushAttrib(GL_LIGHTING_BIT);

1679

glDisable(GL_LIGHTING);

1680

glBegin(GL_LINES);

1681

//Draw lines

1682

glColor3f(1.0f,0.0f,0.0f);

1683

glVertex3f(position[0]-halfSize,

1684

position[1],position[2]);

1685

glVertex3f(position[0]+halfSize,

1686

position[1],position[2]);

1687

1688

glColor3f(0.0f,1.0f,0.0f);

1689

glVertex3f(position[0],

1690

position[1]-halfSize,position[2]);

1691

glVertex3f(position[0],

1692

position[1]+halfSize,position[2]);

1693

1694

glColor3f(0.0f,0.0f,1.0f);

1695

glVertex3f(position[0],

1696

position[1],position[2]-halfSize);

1697

glVertex3f(position[0],

1698

position[1],position[2]+halfSize);

1699

glEnd();

1700

glPopAttrib();

1701

1702

1703

1704

float numSections=20.0f;

1705

float twoPi = 2.0f *M_PI;

1706

float radius = 0.1*halfSize;

1707

//Draw axis cones

1708

1709

//+x

1710

glPushMatrix();

1711

glTranslatef(position[0]+halfSize,position[1],position[2]);

1712

1713

glColor3f(1.0f,0.0f,0.0f);

1714

glBegin(GL_TRIANGLE_FAN);

1715

glVertex3f(radius,0,0);

1716

glNormal3f(1,0,0);

1717

for (unsigned int i = 0; i<=numSections; i++)

1718

{

1719

glVertex3f(0,radius * cos(i * twoPi / numSections),

1720

radius* sin(i * twoPi / numSections));

1721

glNormal3f(0,cos(i*twoPi/numSections),sin(i*twoPi/numSections));

1722

}

1723

glEnd();

1724

glBegin(GL_TRIANGLE_FAN);

1725

glVertex3f(0,0,0);

1726

glNormal3f(-1,0,0);

1727

for (unsigned int i = 0; i<=numSections; i++)

1728

{

1729

glVertex3f(0,-radius * cos(i * twoPi / numSections),

1730

radius* sin(i * twoPi / numSections));

1731

glNormal3f(-1,0,0);

1732

}

1733

glEnd();

1734

glPopMatrix();

1735

1736

//+y

1737

glColor3f(0.0f,1.0f,0.0f);

1738

glPushMatrix();

1739

glTranslatef(position[0],position[1]+halfSize,position[2]);

1740

glBegin(GL_TRIANGLE_FAN);

1741

glVertex3f(0,radius,0);

1742

glNormal3f(0,1,0);

1743

for (unsigned int i = 0; i<=numSections; i++)

1744

{

1745

glVertex3f(radius * sin(i * twoPi / numSections),0,

1746

radius* cos(i * twoPi / numSections));

1747

glNormal3f(sin(i*twoPi/numSections),0,cos(i*twoPi/numSections));

1748

}

1749

glEnd();

1750

1751

glBegin(GL_TRIANGLE_FAN);

1752

glVertex3f(0,0,0);

1753

glNormal3f(0,-1,0);

1754

for (unsigned int i = 0; i<=numSections; i++)

1755

{

1756

glVertex3f(radius * cos(i * twoPi / numSections),0,

1757

radius* sin(i * twoPi / numSections));

1758

glNormal3f(0,-1,0);

1759

}

1760

glEnd();

1761

1762

glPopMatrix();

1763

1764

1765

1766

//+z

1767

glColor3f(0.0f,0.0f,1.0f);

1768

glPushMatrix();

1769

glTranslatef(position[0],position[1],position[2]+halfSize);

1770

glBegin(GL_TRIANGLE_FAN);

1771

glVertex3f(0,0,radius);

1772

glNormal3f(0,0,1);

1773

for (unsigned int i = 0; i<=numSections; i++)

1774

{

1775

glVertex3f(radius * cos(i * twoPi / numSections),

1776

radius* sin(i * twoPi / numSections),0);

1777

glNormal3f(cos(i*twoPi/numSections),sin(i*twoPi/numSections),0);

1778

}

1779

glEnd();

1780

1781

glBegin(GL_TRIANGLE_FAN);

1782

glVertex3f(0,0,0);

1783

glNormal3f(0,0,-1);

1784

for (unsigned int i = 0; i<=numSections; i++)

1785

{

1786

glVertex3f(-radius * cos(i * twoPi / numSections),

1787

radius* sin(i * twoPi / numSections),0);

1788

glNormal3f(0,0,-1);

1789

}

1790

glEnd();

1791

glPopMatrix();

1792

}

1793

1794

void DrawAxis::getBoundingBox(BoundCube &b) const

1795

{

1796

b.setInvalid();

1797

}

1798

1799

1800

void DrawDepthSorted::draw() const

1801

{

1802

bool needResort;

1803

//Check to see if we need to re-sort the data

1804

needResort=(!haveLastDist ||

1805

lastCamLoc.sqrDist(curCamera->getOrigin()) >DEPTH_SORT_REORDER_EPSILON);

1806

1807

if(needResort)

1808

{

1809

//Rebuild the depthJump key data

1810

std::vector<pair<std::pair<size_t,size_t> , float> > dists;

1811

1812

size_t size;

1813

size=0;

1814

for(size_t ui=0;ui<depthObjects.size(); ui++)

1815

size+=dists.size();

1816

1817

dists.resize(size);

1818

depthJumpKeys.resize(size);

1819

1820

//Generate the to-camera distances (negative because we want

1821

//further away objects to be first)

1822

#pragma omp parallel for

1823

for(size_t ui=0;ui<depthObjects.size(); ui++)

1824

{

1825

Point3D centroid;

1826

for(size_t uj=0; uj<depthObjects[ui].second.size(); uj++)

1827

{

1828

centroid=depthObjects[ui].second[uj]->getCentroid();

1829

dists[ui+uj]=std::make_pair(std::make_pair(ui,uj),-centroid.sqrDist(curCamera->getOrigin()));

1830

}

1831

}

1832

1833

//Now we have the distance data, sort it

1834

ComparePairSecond cmp;

1835

std::sort(dists.begin(),dists.end(),cmp);

1836

1837

//Now set the depth Jump Keys using the sorted distances

1838

#pragma omp parallel for

1839

for(size_t ui=0;ui<dists.size();ui++)

1840

depthJumpKeys[ui]=dists[ui].first;

1841

1842

lastCamLoc=curCamera->getOrigin();

1843

}

1844

1845

1846

//OK, so we have to now draw our objects from back->front order

1847

//as set by depthJumpKeys

1848

for(size_t ui=0;ui<depthObjects.size();ui++)

1849

{

1850

const DrawableObj *d;

1851

d=(depthObjects[depthJumpKeys[ui].first].second[depthJumpKeys[ui].second]);

1852

d->draw();

1853

}

1854

}

1855

1856

1857

void DrawDepthSorted::addObjectsAsNeeded(const DrawableObj *obj)

1858

{

1859

size_t off=std::numeric_limits<size_t>::max();

1860

for(size_t ui=0;ui<depthObjects.size();ui++)

1861

{

1862

if(depthObjects[ui].first == obj)

1863

{

1864

if(depthObjects[ui].first->hasChanged())

1865

off=ui;

1866

else

1867

off=depthObjects.size();

1868

1869

break;

1870

}

1871

}

1872

1873

1874

if(off==depthObjects.size())

1875

return; // Object exists and is up to date.

1876

else if(off==std::numeric_limits<size_t>::max())

1877

{

1878

//Ok, so we have no object, and we need

1879

//to create a new set of data

1880

1881

}

1882

else

1883

{

1884

ASSERT(off < depthObjects.size());

1885

//we need to update the object

1886

}

1887

1888

1889

}

1890

1891

1892

Older »