Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Scalemarkers numbered #1131

Merged
merged 6 commits into from Jan 8, 2015
Merged

Scalemarkers numbered #1131

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
1068f61
Add optional menu driven scaling tics to the large axes
TDeagan Dec 27, 2014
b6dcea1
Merge remote-tracking branch 'upstream/master' into scalemarkers
TDeagan Dec 27, 2014
4823f26
Addition of function to generate scale maker numeric values on large …
TDeagan Dec 29, 2014
1826aa9
Addition of header to support function to print scale marker position…
TDeagan Dec 29, 2014
7a71e59
Fix layout of number 6 character & add comments
TDeagan Dec 30, 2014
358ba86
Swap out spaces for tabs
TDeagan Jan 2, 2015
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
Binary file added images/scalemarkers.png
View file
Open in desktop
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
1 change: 1 addition & 0 deletions openscad.qrc
View file
Open in desktop
Expand Up @@ -59,5 +59,6 @@
<file>images/perspective1white.png</file>
<file>images/crosswhite.png</file>
<file>icons/background.png</file>
<file>images/scalemarkers.png</file>
</qresource>
</RCC>
321 changes: 321 additions & 0 deletions src/GLView.cc
View file
Open in desktop
Expand Up @@ -23,6 +23,7 @@ GLView::GLView()
showfaces = true;
showaxes = false;
showcrosshairs = false;
showscale = false;
renderer = NULL;
colorscheme = &ColorMap::inst()->defaultColorScheme();
cam = Camera();
Expand Down Expand Up @@ -164,6 +165,8 @@ void GLView::paintGL()
glTranslated(cam.object_trans.x(), cam.object_trans.y(), cam.object_trans.z());
// ...the axis lines need to follow the object translation.
if (showaxes) GLView::showAxes(bgcontrast);
// mark the scale along the axis lines
if (showscale) GLView::showScalemarkers(bgcontrast);
}

glEnable(GL_LIGHTING);
Expand Down Expand Up @@ -496,3 +499,321 @@ void GLView::showCrosshairs()
glEnd();
}

void GLView::showScalemarkers(const Color4f &col)
{
// Add scale tics on large axes
double l = cam.projection == Camera::PERSPECTIVE ? cam.viewer_distance : cam.height;
glLineWidth(this->getDPI());
glColor3f(col[0], col[1], col[2]);

// determine the log value to provide proportional tics
int log_l = (int)log10(l);

// j represents the increment for each minor tic
double j = 10;
// deal with 0 log values
if (l < 1.5){
j = pow(10,log_l-2);
} else {
j = pow(10,log_l-1);
}

int size_div_sm = 60; // divisor for l to determine minor tic size
int size_div = size_div_sm;
int line_cnt = 0;

for (double i=0;i<l;i+=j){ // i represents the position along the axis
if (line_cnt++ == 10){ // major tic
size_div = size_div_sm * .5; // resize to a major tic
line_cnt = 1; // reset the major tic counter
GLView::decodeMarkerValue(i, l, size_div_sm); // print number
} else { // minor tic
size_div = size_div_sm; // set the minor tic to the standard size
}

/*
* The length of each tic is proportional to the length of the axis
* (which changes with the zoom value.) l/size_div provides the
* proportional length
*
* Commented glVertex3d lines provide additional 'arms' for the tic
* the number of arms will (hopefully) eventually be driven via Preferences
*/

// positive axes
glBegin(GL_LINES);
// x
glVertex3d(i,0,0); glVertex3d(i,-l/size_div,0); // 1 arm
//glVertex3d(i,-l/size_div,0); glVertex3d(i,l/size_div,0); // 2 arms
//glVertex3d(i,0,-l/size_div); glVertex3d(i,0,l/size_div); // 4 arms (w/ 2 arms line)

// y
glVertex3d(0,i,0); glVertex3d(-l/size_div,i,0); // 1 arm
//glVertex3d(-l/size_div,i,0); glVertex3d(l/size_div,i,0); // 2 arms
//glVertex3d(0,i,-l/size_div); glVertex3d(0,i,l/size_div); // 4 arms (w/ 2 arms line)

// z
glVertex3d(0,0,i); glVertex3d(-l/size_div,0,i); // 1 arm
//glVertex3d(-l/size_div,0,i); glVertex3d(l/size_div,0,i); // 2 arms
//glVertex3d(0,-l/size_div,i); glVertex3d(0,l/size_div,i); // 4 arms (w/ 2 arms line)
glEnd();

// negative axes
glPushAttrib(GL_LINE_BIT);
glEnable(GL_LINE_STIPPLE);
glLineStipple(3, 0xAAAA);
glBegin(GL_LINES);
// x
glVertex3d(-i,0,0); glVertex3d(-i,-l/size_div,0); // 1 arm
//glVertex3d(-i,-l/size_div,0); glVertex3d(-i,l/size_div,0); // 2 arms
//glVertex3d(-i,0,-l/size_div); glVertex3d(-i,0,l/size_div); // 4 arms (w/ 2 arms line)

// y
glVertex3d(0,-i,0); glVertex3d(-l/size_div,-i,0); // 1 arm
//glVertex3d(-l/size_div,-i,0); glVertex3d(l/size_div,-i,0); // 2 arms
//glVertex3d(0,-i,-l/size_div); glVertex3d(0,-i,l/size_div); // 4 arms (w/ 2 arms line)

// z
glVertex3d(0,0,-i); glVertex3d(-l/size_div,0,-i); // 1 arm
//glVertex3d(-l/size_div,0,-i); glVertex3d(l/size_div,0,-i); // 2 arms
//glVertex3d(0,-l/size_div,-i); glVertex3d(0,l/size_div,-i); // 4 arms (w/ 2 arms line)
glEnd();
glPopAttrib();
}
}

void GLView::decodeMarkerValue(double i, double l, int size_div_sm)
{
// convert the axis position to a string
std::string digit = static_cast<std::ostringstream*>( &(std::ostringstream() << i) )->str();

// setup how far above the axis (or tic TBD) to draw the number
double dig_buf = (l/size_div_sm)/4;
// setup the size of the character box
double dig_w = (l/size_div_sm)/2;
double dig_h = (l/size_div_sm) + dig_buf;
// setup the distance between characters
double kern = dig_buf;
double dig_wk = (dig_w) + kern;

// set up ordering for different axes
int ax[6][3] = {
{0,1,2},
{1,0,2},
{1,2,0},
{0,1,2},
{1,0,2},
{1,2,0}};

// set up character vertex seqeunces for different axes
int or_2[6][6]={
{0,1,3,2,4,5},
{1,0,2,3,5,4},
{1,0,2,3,5,4},
{1,0,2,3,5,4},
{0,1,3,2,4,5},
{0,1,3,2,4,5}};

int or_3[6][7]={
{0,1,3,2,3,5,4},
{1,0,2,3,2,4,5},
{1,0,2,3,2,4,5},
{1,0,2,3,2,4,5},
{0,1,3,2,3,5,4},
{0,1,3,2,3,5,4}};

int or_4[6][5]={
{0,2,3,1,5},
{1,3,2,0,4},
{1,3,2,0,4},
{1,3,2,0,4},
{0,2,3,1,5},
{0,2,3,1,5}};

int or_5[6][6]={
{1,0,2,3,5,4},
{0,1,3,2,4,5},
{0,1,3,2,4,5},
{0,1,3,2,4,5},
{1,0,2,3,5,4},
{1,0,2,3,5,4}};

int or_6[6][6]={
{1,0,4,5,3,2},
{0,1,5,4,2,3},
{0,1,5,4,2,3},
{0,1,5,4,2,3},
{1,0,4,5,3,2},
{1,0,4,5,3,2}};

int or_7[6][3]={
{0,1,4},
{1,0,5},
{1,0,5},
{1,0,5},
{0,1,4},
{0,1,4}};

int or_9[6][5]={
{5,1,0,2,3},
{4,0,1,3,2},
{4,0,1,3,2},
{4,0,1,3,2},
{5,1,0,2,3},
{5,1,0,2,3}};

std::string stash_digit = digit;

// walk through axes
for (int di=0;di<6;di++){

// setup negative axes
double polarity = 1;
if (di>2){
polarity = -1;
digit = "-" + stash_digit;
}

// fix the axes that need to run the opposite direction
if (di>0 && di<4){
std::reverse(digit.begin(),digit.end());
}

// walk through and render the characters of the string
for(std::string::size_type char_num = 0; char_num < digit.size(); ++char_num){
// setup the vertices for the char rendering based on the axis and position
double dig_vrt[6][3] = {
{polarity*((i+((char_num)*dig_wk))-(dig_w/2)),dig_h,0},
{polarity*((i+((char_num)*dig_wk))+(dig_w/2)),dig_h,0},
{polarity*((i+((char_num)*dig_wk))-(dig_w/2)),dig_h/2+dig_buf,0},
{polarity*((i+((char_num)*dig_wk))+(dig_w/2)),dig_h/2+dig_buf,0},
{polarity*((i+((char_num)*dig_wk))-(dig_w/2)),dig_buf,0},
{polarity*((i+((char_num)*dig_wk))+(dig_w/2)),dig_buf,0}};

// convert the char into lines appropriate for the axis being used
// psuedo 7 segment vertices are:
// A--B
// | |
// C--D
// | |
// E--F
switch(digit[char_num]){
case '1':
glBegin(GL_LINES);
glVertex3d(dig_vrt[0][ax[di][0]],dig_vrt[0][ax[di][1]],dig_vrt[0][ax[di][2]]); //a
glVertex3d(dig_vrt[4][ax[di][0]],dig_vrt[4][ax[di][1]],dig_vrt[4][ax[di][2]]); //e
glEnd();
break;

case '2':
glBegin(GL_LINE_STRIP);
glVertex3d(dig_vrt[or_2[di][0]][ax[di][0]],dig_vrt[or_2[di][0]][ax[di][1]],dig_vrt[or_2[di][0]][ax[di][2]]); //a
glVertex3d(dig_vrt[or_2[di][1]][ax[di][0]],dig_vrt[or_2[di][1]][ax[di][1]],dig_vrt[or_2[di][1]][ax[di][2]]); //b
glVertex3d(dig_vrt[or_2[di][2]][ax[di][0]],dig_vrt[or_2[di][2]][ax[di][1]],dig_vrt[or_2[di][2]][ax[di][2]]); //d
glVertex3d(dig_vrt[or_2[di][3]][ax[di][0]],dig_vrt[or_2[di][3]][ax[di][1]],dig_vrt[or_2[di][3]][ax[di][2]]); //c
glVertex3d(dig_vrt[or_2[di][4]][ax[di][0]],dig_vrt[or_2[di][4]][ax[di][1]],dig_vrt[or_2[di][4]][ax[di][2]]); //e
glVertex3d(dig_vrt[or_2[di][5]][ax[di][0]],dig_vrt[or_2[di][5]][ax[di][1]],dig_vrt[or_2[di][5]][ax[di][2]]); //f
glEnd();
break;

case '3':
glBegin(GL_LINE_STRIP);
glVertex3d(dig_vrt[or_3[di][0]][ax[di][0]],dig_vrt[or_3[di][0]][ax[di][1]],dig_vrt[or_3[di][0]][ax[di][2]]); //a
glVertex3d(dig_vrt[or_3[di][1]][ax[di][0]],dig_vrt[or_3[di][1]][ax[di][1]],dig_vrt[or_3[di][1]][ax[di][2]]); //b
glVertex3d(dig_vrt[or_3[di][2]][ax[di][0]],dig_vrt[or_3[di][2]][ax[di][1]],dig_vrt[or_3[di][2]][ax[di][2]]); //d
glVertex3d(dig_vrt[or_3[di][3]][ax[di][0]],dig_vrt[or_3[di][3]][ax[di][1]],dig_vrt[or_3[di][3]][ax[di][2]]); //c
glVertex3d(dig_vrt[or_3[di][4]][ax[di][0]],dig_vrt[or_3[di][4]][ax[di][1]],dig_vrt[or_3[di][4]][ax[di][2]]); //d
glVertex3d(dig_vrt[or_3[di][5]][ax[di][0]],dig_vrt[or_3[di][5]][ax[di][1]],dig_vrt[or_3[di][5]][ax[di][2]]); //f
glVertex3d(dig_vrt[or_3[di][6]][ax[di][0]],dig_vrt[or_3[di][6]][ax[di][1]],dig_vrt[or_3[di][6]][ax[di][2]]); //e
glEnd();
break;

case '4':
glBegin(GL_LINE_STRIP);
glVertex3d(dig_vrt[or_4[di][0]][ax[di][0]],dig_vrt[or_4[di][0]][ax[di][1]],dig_vrt[or_4[di][0]][ax[di][2]]); //a
glVertex3d(dig_vrt[or_4[di][1]][ax[di][0]],dig_vrt[or_4[di][1]][ax[di][1]],dig_vrt[or_4[di][1]][ax[di][2]]); //c
glVertex3d(dig_vrt[or_4[di][2]][ax[di][0]],dig_vrt[or_4[di][2]][ax[di][1]],dig_vrt[or_4[di][2]][ax[di][2]]); //d
glVertex3d(dig_vrt[or_4[di][3]][ax[di][0]],dig_vrt[or_4[di][3]][ax[di][1]],dig_vrt[or_4[di][3]][ax[di][2]]); //b
glVertex3d(dig_vrt[or_4[di][4]][ax[di][0]],dig_vrt[or_4[di][4]][ax[di][1]],dig_vrt[or_4[di][4]][ax[di][2]]); //f
glEnd();
break;

case '5':
glBegin(GL_LINE_STRIP);
glVertex3d(dig_vrt[or_5[di][0]][ax[di][0]],dig_vrt[or_5[di][0]][ax[di][1]],dig_vrt[or_5[di][0]][ax[di][2]]); //b
glVertex3d(dig_vrt[or_5[di][1]][ax[di][0]],dig_vrt[or_5[di][1]][ax[di][1]],dig_vrt[or_5[di][1]][ax[di][2]]); //a
glVertex3d(dig_vrt[or_5[di][2]][ax[di][0]],dig_vrt[or_5[di][2]][ax[di][1]],dig_vrt[or_5[di][2]][ax[di][2]]); //c
glVertex3d(dig_vrt[or_5[di][3]][ax[di][0]],dig_vrt[or_5[di][3]][ax[di][1]],dig_vrt[or_5[di][3]][ax[di][2]]); //d
glVertex3d(dig_vrt[or_5[di][4]][ax[di][0]],dig_vrt[or_5[di][4]][ax[di][1]],dig_vrt[or_5[di][4]][ax[di][2]]); //f
glVertex3d(dig_vrt[or_5[di][5]][ax[di][0]],dig_vrt[or_5[di][5]][ax[di][1]],dig_vrt[or_5[di][5]][ax[di][2]]); //e
glEnd();
break;

case '6':
glBegin(GL_LINE_STRIP);
glVertex3d(dig_vrt[or_6[di][0]][ax[di][0]],dig_vrt[or_6[di][0]][ax[di][1]],dig_vrt[or_6[di][0]][ax[di][2]]); //b
glVertex3d(dig_vrt[or_6[di][1]][ax[di][0]],dig_vrt[or_6[di][1]][ax[di][1]],dig_vrt[or_6[di][1]][ax[di][2]]); //a
glVertex3d(dig_vrt[or_6[di][2]][ax[di][0]],dig_vrt[or_6[di][2]][ax[di][1]],dig_vrt[or_6[di][2]][ax[di][2]]); //e
glVertex3d(dig_vrt[or_6[di][3]][ax[di][0]],dig_vrt[or_6[di][3]][ax[di][1]],dig_vrt[or_6[di][3]][ax[di][2]]); //f
glVertex3d(dig_vrt[or_6[di][4]][ax[di][0]],dig_vrt[or_6[di][4]][ax[di][1]],dig_vrt[or_6[di][4]][ax[di][2]]); //d
glVertex3d(dig_vrt[or_6[di][5]][ax[di][0]],dig_vrt[or_6[di][5]][ax[di][1]],dig_vrt[or_6[di][5]][ax[di][2]]); //c
glEnd();
break;

case '7':
glBegin(GL_LINE_STRIP);
glVertex3d(dig_vrt[or_7[di][0]][ax[di][0]],dig_vrt[or_7[di][0]][ax[di][1]],dig_vrt[or_7[di][0]][ax[di][2]]); //a
glVertex3d(dig_vrt[or_7[di][1]][ax[di][0]],dig_vrt[or_7[di][1]][ax[di][1]],dig_vrt[or_7[di][1]][ax[di][2]]); //b
glVertex3d(dig_vrt[or_7[di][2]][ax[di][0]],dig_vrt[or_7[di][2]][ax[di][1]],dig_vrt[or_7[di][2]][ax[di][2]]); //e
glEnd();
break;

case '8':
glBegin(GL_LINE_STRIP);
glVertex3d(dig_vrt[2][ax[di][0]],dig_vrt[2][ax[di][1]],dig_vrt[2][ax[di][2]]); //c
glVertex3d(dig_vrt[3][ax[di][0]],dig_vrt[3][ax[di][1]],dig_vrt[3][ax[di][2]]); //d
glVertex3d(dig_vrt[1][ax[di][0]],dig_vrt[1][ax[di][1]],dig_vrt[1][ax[di][2]]); //b
glVertex3d(dig_vrt[0][ax[di][0]],dig_vrt[0][ax[di][1]],dig_vrt[0][ax[di][2]]); //a
glVertex3d(dig_vrt[4][ax[di][0]],dig_vrt[4][ax[di][1]],dig_vrt[4][ax[di][2]]); //e
glVertex3d(dig_vrt[5][ax[di][0]],dig_vrt[5][ax[di][1]],dig_vrt[5][ax[di][2]]); //f
glVertex3d(dig_vrt[3][ax[di][0]],dig_vrt[3][ax[di][1]],dig_vrt[3][ax[di][2]]); //d
glEnd();
break;

case '9':
glBegin(GL_LINE_STRIP);
glVertex3d(dig_vrt[or_9[di][0]][ax[di][0]],dig_vrt[or_9[di][0]][ax[di][1]],dig_vrt[or_9[di][0]][ax[di][2]]); //f
glVertex3d(dig_vrt[or_9[di][1]][ax[di][0]],dig_vrt[or_9[di][1]][ax[di][1]],dig_vrt[or_9[di][1]][ax[di][2]]); //b
glVertex3d(dig_vrt[or_9[di][2]][ax[di][0]],dig_vrt[or_9[di][2]][ax[di][1]],dig_vrt[or_9[di][2]][ax[di][2]]); //a
glVertex3d(dig_vrt[or_9[di][3]][ax[di][0]],dig_vrt[or_9[di][3]][ax[di][1]],dig_vrt[or_9[di][3]][ax[di][2]]); //c
glVertex3d(dig_vrt[or_9[di][4]][ax[di][0]],dig_vrt[or_9[di][4]][ax[di][1]],dig_vrt[or_9[di][4]][ax[di][2]]); //d
glEnd();
break;

case '0':
glBegin(GL_LINE_LOOP);
glVertex3d(dig_vrt[0][ax[di][0]],dig_vrt[0][ax[di][1]],dig_vrt[0][ax[di][2]]); //a
glVertex3d(dig_vrt[1][ax[di][0]],dig_vrt[1][ax[di][1]],dig_vrt[1][ax[di][2]]); //b
glVertex3d(dig_vrt[5][ax[di][0]],dig_vrt[5][ax[di][1]],dig_vrt[5][ax[di][2]]); //f
glVertex3d(dig_vrt[4][ax[di][0]],dig_vrt[4][ax[di][1]],dig_vrt[4][ax[di][2]]); //e
glEnd();
break;

case '-':
glBegin(GL_LINES);
glVertex3d(dig_vrt[2][ax[di][0]],dig_vrt[2][ax[di][1]],dig_vrt[2][ax[di][2]]); //c
glVertex3d(dig_vrt[3][ax[di][0]],dig_vrt[3][ax[di][1]],dig_vrt[3][ax[di][2]]); //d
glEnd();
break;

case '.':
glBegin(GL_LINES);
glVertex3d(dig_vrt[4][ax[di][0]],dig_vrt[4][ax[di][1]],dig_vrt[4][ax[di][2]]); //e
glVertex3d(dig_vrt[5][ax[di][0]],dig_vrt[5][ax[di][1]],dig_vrt[5][ax[di][2]]); //f
glEnd();
break;
}
}
}
}

3 changes: 3 additions & 0 deletions src/GLView.h
View file
Open in desktop
Expand Up @@ -62,6 +62,7 @@ class GLView
bool showfaces;
bool showedges;
bool showcrosshairs;
bool showscale;

#ifdef ENABLE_OPENCSG
GLint shaderinfo[11];
Expand All @@ -76,4 +77,6 @@ class GLView
void showCrosshairs();
void showAxes(const Color4f &col);
void showSmallaxes(const Color4f &col);
void showScalemarkers(const Color4f &col);
void decodeMarkerValue(double i, double l, int size_div_sm);
};
1 change: 1 addition & 0 deletions src/MainWindow.h
View file
Open in desktop
Expand Up @@ -213,6 +213,7 @@ public slots:
void viewModeShowEdges();
void viewModeShowAxes();
void viewModeShowCrosshairs();
void viewModeShowScaleProportional();
void viewModeAnimate();
void viewAngleTop();
void viewAngleBottom();
Expand Down
16 changes: 16 additions & 0 deletions src/MainWindow.ui
View file
Open in desktop
Expand Up @@ -274,6 +274,7 @@
<addaction name="viewActionShowEdges"/>
<addaction name="viewActionShowAxes"/>
<addaction name="viewActionShowCrosshairs"/>
<addaction name="viewActionShowScaleProportional"/>
<addaction name="viewActionAnimate"/>
<addaction name="separator"/>
<addaction name="viewActionTop"/>
Expand Down Expand Up @@ -826,6 +827,21 @@
<string>Ctrl+3</string>
</property>
</action>
<action name="viewActionShowScaleProportional">
<property name="checkable">
<bool>true</bool>
</property>
<property name="icon">
<iconset resource="../openscad.qrc">
<normaloff>:/images/scalemarkers.png</normaloff>:/images/scalemarkers.png</iconset>
</property>
<property name="text">
<string>Show Scale Markers</string>
</property>
<!--<property name="shortcut">
<string></string>
</property>-->
</action>
<action name="viewActionAnimate">
<property name="checkable">
<bool>true</bool>
Expand Down