suzanne.soy/FreeCAD
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Working revolving part DPG

Browse Source
This commit is contained in:
WandererFan 2016-12-25 16:24:44 -05:00 committed by wmayer
parent 90935d0600
commit 139edb2415
9 changed files with 401 additions and 421 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

333
src/Mod/TechDraw/App/Cube.cpp
View File

@ -27,7 +27,6 @@
#endif
#include <Base/Console.h>
//#include <Base/Vector3D.h>
#include "DrawUtil.h"
#include "Cube.h"
@ -55,17 +54,14 @@ Cube::~Cube(void)
{
}
// D/C/A/F/B/E/FBL/FBR/FTL/FTR
void Cube::initialize(Base::Vector3d r, Base::Vector3d rr, Base::Vector3d l, Base::Vector3d lr,
Base::Vector3d f, Base::Vector3d fr, Base::Vector3d k, Base::Vector3d kr, //k for bacK (rear)
Base::Vector3d t, Base::Vector3d tr, Base::Vector3d b, Base::Vector3d br,
Base::Vector3d fbl, Base::Vector3d fblr, Base::Vector3d fbr, Base::Vector3d fbrr,
Base::Vector3d ftl, Base::Vector3d ftlr, Base::Vector3d ftr, Base::Vector3d ftrr)
{
Base::Console().Message("TRACE - Cube::init()\n");
//Base::Vector3d FTR = f+t+r;
//Base::Vector3d FTL = f+t-r;
//Base::Vector3d FBL = f-t-r;
//Base::Vector3d FBR = -f-t-r;
//these frames are only used at DPGI creation time?
m_mapFrameDir.clear();
m_mapFrameDir.insert(std::map<std::string, Base::Vector3d>::value_type("Bottom", b));
m_mapFrameDir.insert(std::map<std::string, Base::Vector3d>::value_type("Front" , f));
@ -90,8 +86,7 @@ void Cube::initialize(Base::Vector3d r, Base::Vector3d rr, Base::Vector3d l, Bas
m_mapFrameRot.insert(std::map<std::string, Base::Vector3d>::value_type("FrontBottomLeft" , fblr));
m_mapFrameRot.insert(std::map<std::string, Base::Vector3d>::value_type("FrontBottomRight", fbrr));
m_conTab.initialize(); //all possible configs of ABCDEF in RightFrontTopLeftRearBottom order
// m_conTab.dump("conTab after init");
m_conTab.initialize(); //all possible configs of ABCDEF in bottom/front/left/(k)rear/right/top order
}
void Cube::rotateUp()
@ -103,18 +98,13 @@ void Cube::rotateUp()
shiftFrame("Top" , "Rear");
restoreSwap("Top");
updateIsoDirs();
updateRotsToConfig(getCurrConfig());
updateIsoRots();
dump("RotateUp(board after Rot update)");
// dumpState("RotateUp(after update)");
//validateBoard();
updateIsoDirs(); //calculatge iso directions from ortho dirs
updateRotsToConfig(getCurrConfig()); //update rotations for ortho views from config table
updateIsoRots(); //calculate iso rotations from iso/ortho dirs
}
void Cube::rotateDown()
{
//Front -> Bottom -> Rear -> Top -> Front???
saveSwap("Front");
shiftFrame("Top" , "Front");
@ -125,16 +115,10 @@ void Cube::rotateDown()
updateIsoDirs();
updateRotsToConfig(getCurrConfig());
updateIsoRots();
dump("RotateDown(board after Rot update)");
// dumpState("RotateDown(after update)");
//validateBoard();
}
void Cube::rotateRight()
{
//dump("RotateRight (board before)");
//Front -> Right -> Rear -> Left -> Front???
saveSwap("Front");
shiftFrame("Left" , "Front");
@ -145,10 +129,6 @@ void Cube::rotateRight()
updateIsoDirs();
updateRotsToConfig(getCurrConfig());
updateIsoRots();
dump("RotateRight(board after Rot update)");
// bool boardState = validateBoard(getCurrConfig());
// Base::Console().Message("TRACE - Cube::rotateRight - boardState: %d\n",boardState);
// dumpState("RotateRight(state after update)");
}
void Cube::rotateLeft()
@ -163,9 +143,6 @@ void Cube::rotateLeft()
updateIsoDirs();
updateRotsToConfig(getCurrConfig());
updateIsoRots();
dump("RotateLeft(board after Rot updates)");
// dumpState("RotateLeft(after update)");
}
void Cube::spinCCW()
@ -180,8 +157,6 @@ void Cube::spinCCW()
updateIsoDirs();
updateRotsToConfig(getCurrConfig());
updateIsoRots();
dump("SpinCCW(board after Rot updates)");
// dumpState("SpinCCW(after update)");
}
void Cube::spinCW()
@ -196,8 +171,6 @@ void Cube::spinCW()
updateIsoDirs();
updateRotsToConfig(getCurrConfig());
updateIsoRots();
dump("spinCW(board after Rot updates)");
// dumpState("SpinCW(after update)");
}
void Cube::updateIsoDirs()
@ -214,14 +187,14 @@ void Cube::updateIsoDirs()
void Cube::updateIsoRots()
{
Base::Vector3d flb = getFrontRot() + getLeftRot() + getBottomRot();
Base::Vector3d frb = getFrontRot() + getRightRot() + getBottomRot();
Base::Vector3d flt = getFrontRot() + getLeftRot() + getTopRot();
Base::Vector3d frt = getFrontRot() + getRightRot() + getTopRot();
m_mapFrameRot.at("FrontBottomLeft") = flb;
m_mapFrameRot.at("FrontBottomRight") = frb;
m_mapFrameRot.at("FrontTopLeft") = flt;
m_mapFrameRot.at("FrontTopRight") = frt;
// Base::Vector3d flb = getFrontRot() + getLeftRot() + getBottomRot();
// Base::Vector3d frb = getFrontRot() + getRightRot() + getBottomRot();
// Base::Vector3d flt = getFrontRot() + getLeftRot() + getTopRot();
//// Base::Vector3d frt = getFrontRot() + getRightRot() + getTopRot();
// m_mapFrameRot.at("FrontBottomLeft") = flb;
// m_mapFrameRot.at("FrontBottomRight") = frb;
// m_mapFrameRot.at("FrontTopLeft") = flt;
//// m_mapFrameRot.at("FrontTopRight") = frt;
}
std::string Cube::dirToView(Base::Vector3d v)
@ -238,7 +211,6 @@ std::string Cube::dirToView(Base::Vector3d v)
void Cube::updateDirsToConfig(std::string cfg)
{
Base::Console().Message("TRACE - Cube::updateDirs(%s) \n",cfg.c_str());
Base::Vector3d boardValue = m_conTab.getDirItem(cfg,"Front");
m_mapFrameDir.at("Front") = boardValue;
boardValue = m_conTab.getDirItem(cfg,"Rear");
@ -255,7 +227,6 @@ void Cube::updateDirsToConfig(std::string cfg)
void Cube::updateRotsToConfig(std::string cfg)
{
Base::Console().Message("TRACE - Cube::updateRots(%s) \n",cfg.c_str());
Base::Vector3d boardValue = m_conTab.getRotItem(cfg,"Front");
m_mapFrameRot.at("Front") = boardValue;
boardValue = m_conTab.getRotItem(cfg,"Rear");
@ -272,22 +243,16 @@ void Cube::updateRotsToConfig(std::string cfg)
bool Cube::validateBoard(std::string cfg)
{
// Base::Console().Message("TRACE - Cube::validateBoard(%s)\n",cfg.c_str());
bool result = true;
//check that Dirs match
std::string strCfgDir;
std::string strBoardDir;
// Base::Console().Message("TRACE - Cube::validateBoard(%s) - BoardDirCount: %d BoardRotCount: %d\n",
// cfg.c_str(),m_mapFrameDir.size(),m_mapFrameRot.size());
for (auto& f: m_mapFrameDir) {
Base::Vector3d boardValue = f.second;
strBoardDir += dirToView(boardValue);
}
strCfgDir = m_conTab.getCfgDirStr(cfg);
// Base::Console().Message("TRACE - Cube::validateBoard(%s) - Config Dirs: %s Board Dirs: %s\n",
// cfg.c_str(),strCfgDir.c_str(),strBoardDir.c_str());
if (strCfgDir != strBoardDir) {
result = false;
return result;
@ -305,9 +270,6 @@ bool Cube::validateBoard(std::string cfg)
if (strCfgRot != strBoardRot) {
result = false;
}
// Base::Console().Message("TRACE - Cube::validateBoard - Config Rots: %s Board Rots: %s\n",strCfgRot.c_str(),strBoardRot.c_str());
// Base::Console().Message("TRACE - Cube::validateBoard - result: %d\n",result);
return result;
}
@ -315,11 +277,11 @@ bool Cube::validateBoard(std::string cfg)
std::string Cube::getBoardKey()
{
std::string result;
Base::Vector3d frontDir = m_mapFrameDir.at("Front");
std::string frontView = dirToView(frontDir);
Base::Vector3d rightDir = m_mapFrameDir.at("Right");
std::string rightView = dirToView(rightDir);
result = frontView + rightView;
// Base::Vector3d frontDir = m_mapFrameDir.at("Front");
// std::string frontView = dirToView(frontDir);
// Base::Vector3d rightDir = m_mapFrameDir.at("Right");
// std::string rightView = dirToView(rightDir);
// result = frontView + rightView;
return result;
}
@ -331,30 +293,9 @@ std::string Cube::getCurrConfig(void)
boardValue = m_mapFrameDir.at("Right");
std::string viewRight = dirToView(boardValue);
std::string result = viewFront + viewRight;
// Base::Console().Message("TRACE - Cube::getCurrCon - Result: %s Front: %s Right: %s\n",result.c_str(),viewFront.c_str(),viewRight.c_str());
// for (auto& i : m_mapFrameDir) {
// Base::Console().Message("m_mapFrameDir: %s - %s - %s\n",
// (i.first).c_str(),DrawUtil::formatVector(i.second).c_str(),dirToView(i.second).c_str());
// }
return result;
}
//std::string Cube::stdDirToFace(Base::Vector3d dir)
//{
// std::string result;
//// int i = 0;
//// auto it = m_stdDirToFaceKeys.begin(); //map find and at don't much like vector3d
//// for (; it != m_stdDirToFaceKeys.end(); it++) {
//// Base::Vector3d key = (*it);
//// if ( key == dir ) {
//// result = m_stdDirToFaceData.at(i);
//// break;
//// }
//// i++;
//// }
// return result;
//}
void Cube::saveSwap(std::string frame)
{
m_swapDir = m_mapFrameDir.at(frame);
@ -426,7 +367,6 @@ void Cube::dumpState(char* title)
Base::Vector3d Cube::getRight()
{
std::string myFace = "D";
Base::Vector3d result;
result = m_mapFrameDir.at("Right");
return result;
@ -434,7 +374,6 @@ Base::Vector3d Cube::getRight()
Base::Vector3d Cube::getFront()
{
std::string myFace = "A";
Base::Vector3d result;
result = m_mapFrameDir.at("Front");
return result;
@ -442,7 +381,6 @@ Base::Vector3d Cube::getFront()
Base::Vector3d Cube::getTop()
{
std::string myFace = "B";
Base::Vector3d result;
result = m_mapFrameDir.at("Top");
return result;
@ -450,7 +388,6 @@ Base::Vector3d Cube::getTop()
Base::Vector3d Cube::getLeft()
{
std::string myFace = "C";
Base::Vector3d result;
result = m_mapFrameDir.at("Left");
return result;
@ -458,7 +395,6 @@ Base::Vector3d Cube::getLeft()
Base::Vector3d Cube::getRear()
{
std::string myFace = "F";
Base::Vector3d result;
result = m_mapFrameDir.at("Rear");
return result;
@ -466,7 +402,6 @@ Base::Vector3d Cube::getRear()
Base::Vector3d Cube::getBottom()
{
std::string myFace = "E";
Base::Vector3d result;
result = m_mapFrameDir.at("Bottom");
return result;
@ -511,7 +446,6 @@ Base::Vector3d Cube::getRightRot()
Base::Vector3d Cube::getFrontRot()
{
std::string myFace = "A";
Base::Vector3d result;
result = m_mapFrameRot.at("Front");
return result;
@ -519,7 +453,6 @@ Base::Vector3d Cube::getFrontRot()
Base::Vector3d Cube::getTopRot()
{
std::string myFace = "B";
Base::Vector3d result;
result = m_mapFrameRot.at("Top");
return result;
@ -527,7 +460,6 @@ Base::Vector3d Cube::getTopRot()
Base::Vector3d Cube::getLeftRot()
{
std::string myFace = "C";
Base::Vector3d result;
result = m_mapFrameRot.at("Left");
return result;
@ -535,7 +467,6 @@ Base::Vector3d Cube::getLeftRot()
Base::Vector3d Cube::getRearRot()
{
std::string myFace = "F";
Base::Vector3d result;
result = m_mapFrameRot.at("Rear");
return result;
@ -552,28 +483,81 @@ Base::Vector3d Cube::getBottomRot()
Base::Vector3d Cube::getFBLRot()
{
Base::Vector3d result;
result = m_mapFrameRot.at("FrontBottomLeft");
double magic1 = 157.5 * M_PI / 180.0; // 90 + 45 + magic1
// double magic1 = -22.5 * M_PI / 180.0; //45*/2
double magic2 = -17.632 * M_PI / 180.0; //±35.264° / 2 "magic angle"??
// <<https://en.wikipedia.org/wiki/Isometric_projection#Overview
Base::Vector3d up = getTop();
Base::Vector3d view = getFBL();
Base::Vector3d cross = up.Cross(view);
Base::Vector3d rot1 = DrawUtil::vecRotate(view,magic1,cross);
Base::Vector3d rot2 = DrawUtil::vecRotate(rot1,magic2,up);
result = rot2;
Base::Vector3d viewA = getFront();
if ((viewA == m_viewToStdDir.at("C")) ||
(viewA == m_viewToStdDir.at("D"))) {
result = Base::Vector3d(-1.0*result.x,-1.0*result.y,result.z);
}
return result;
}
Base::Vector3d Cube::getFBRRot()
{
Base::Vector3d result;
result = m_mapFrameRot.at("FrontBottomRight");
double magic1 = -22.5 * M_PI / 180.0; //45*/2
double magic2 = 17.632 * M_PI / 180.0; //±35.264° / 2 "magic angle"
Base::Vector3d up = getTop();
Base::Vector3d view = getFBR();
Base::Vector3d cross = up.Cross(view);
Base::Vector3d rot1 = DrawUtil::vecRotate(view,magic1,cross);
Base::Vector3d rot2 = DrawUtil::vecRotate(rot1,magic2,up);
result = rot2;
Base::Vector3d viewA = getFront();
if ((viewA == m_viewToStdDir.at("C")) ||
(viewA == m_viewToStdDir.at("D"))) {
result = Base::Vector3d(-1.0*result.x,-1.0*result.y,result.z);
}
return result;
}
Base::Vector3d Cube::getFTLRot()
{
Base::Vector3d result;
result = m_mapFrameRot.at("FrontTopLeft");
double magic1 = -157.5 * M_PI / 180.0;
double magic2 = -17.632 * M_PI / 180.0;
//+45? not quite
//-18?
Base::Vector3d up = getTop();
Base::Vector3d view = getFTL();
Base::Vector3d cross = up.Cross(view);
Base::Vector3d rot1 = DrawUtil::vecRotate(view,magic1,cross);
Base::Vector3d rot2 = DrawUtil::vecRotate(rot1,magic2,up);
result = rot2;
Base::Vector3d viewA = getFront();
if ((viewA == m_viewToStdDir.at("C")) ||
(viewA == m_viewToStdDir.at("D"))) {
result = Base::Vector3d(-1.0*result.x,-1.0*result.y,result.z);
}
return result;
}
Base::Vector3d Cube::getFTRRot()
{
Base::Vector3d result;
result = m_mapFrameRot.at("FrontTopRight");
double magic1 = 22.5 * M_PI / 180.0;
double magic2 = 17.632 * M_PI / 180.0;
Base::Vector3d up = getTop();
Base::Vector3d view = getFTR();
Base::Vector3d cross = up.Cross(view);
Base::Vector3d rot1 = DrawUtil::vecRotate(view,magic1,cross);
Base::Vector3d rot2 = DrawUtil::vecRotate(rot1,magic2,up);
result = rot2;
Base::Vector3d viewA = getFront();
if ((viewA == m_viewToStdDir.at("C")) ||
(viewA == m_viewToStdDir.at("D"))) {
result = Base::Vector3d(-1.0*result.x,-1.0*result.y,result.z);
}
return result;
}
@ -600,13 +584,10 @@ Base::Vector3d configLine::getItem(std::string frame)
std::string configLine::getString()
{
//this outputs Bottom/Left/Front/Rear/Right/Top
// Base::Console().Message("TRACE - conLine::getString() - key: %s\n", key.c_str());
std::string result;
for (auto& i: itemMap) {
Base::Vector3d itemVec = i.second;
result += Cube::dirToView(itemVec);
// Base::Console().Message("TRACE - %s - %s/%s\n",
// i.first.c_str(),DrawUtil::formatVector(i.second).c_str(), Cube::dirToView(itemVec).c_str());
}
return result;
}
@ -625,7 +606,6 @@ void configLine::dump(char* title)
std::string configTable::getCfgDirStr(std::string cfg)
{
std::string result;
// Base::Console().Message("TRACE - conTab::getCFGDirStr(%s)\n",cfg.c_str());
configLine dirLine = getDirLine(cfg);
result = dirLine.getString();
return result;
@ -652,14 +632,12 @@ configLine configTable::getRotLine(std::string k)
configLine configTable::getLine(std::string k, std::vector<configLine> list)
{
configLine result;
// Base::Console().Message("TRACE - conTab::getLine(%s)\n",k.c_str());
for (auto& l: list) {
if (k == l.getKey()) {
result = l;
break;
}
}
// Base::Console().Message("result: %s\n",result.getString().c_str());
return result;
}
@ -693,16 +671,163 @@ void configTable::addRotItem(configLine cl)
void configTable::initialize(void)
{
Base::Console().Message("TRACE - cT::initialize()\n");
dirs.clear();
rots.clear();
configLine cl;
//Rotations
#include "rots.cpp"
//Directions items
#include "dirs.cpp"
Base::Console().Message("TRACE - cT::initialize dirs: %d rots %d\n",dirs.size(),rots.size());
//Rotations
//#include "rots.cpp"
// Rots - b/f/l/k/r/t
cl = configLine( 1 , "AB", Base::Vector3d(0,0,1), Base::Vector3d(0,0,1), Base::Vector3d(0,1,0),
Base::Vector3d(0,0,-1), Base::Vector3d(0,-1,0), Base::Vector3d(0,0,1) );
addRotItem(cl);
cl = configLine( 2 , "AC", Base::Vector3d(-1,0,0), Base::Vector3d(-1,0,0), Base::Vector3d(0,1,0),
Base::Vector3d(1,0,0), Base::Vector3d(0,-1,0), Base::Vector3d(-1,0,0) );
addRotItem(cl);
cl = configLine( 3 , "AD", Base::Vector3d(1,0,0), Base::Vector3d(1,0,0), Base::Vector3d(0,1,0),
Base::Vector3d(-1,0,0), Base::Vector3d(0,-1,0), Base::Vector3d(1,0,0) );
addRotItem(cl);
cl = configLine( 4 , "AE", Base::Vector3d(0,0,-1), Base::Vector3d(0,0,-1), Base::Vector3d(0,1,0),
Base::Vector3d(0,0,1), Base::Vector3d(0,-1,0), Base::Vector3d(0,0,-1) );
addRotItem(cl);
cl = configLine( 5 , "BA", Base::Vector3d(0,-1,0), Base::Vector3d(0,1,0), Base::Vector3d(0,0,-1),
Base::Vector3d(0,-1,0), Base::Vector3d(0,0,-1), Base::Vector3d(0,1,0) );
addRotItem(cl);
cl = configLine( 6 , "BC", Base::Vector3d(-1,0,0), Base::Vector3d(-1,0,0), Base::Vector3d(0,0,1),
Base::Vector3d(1,0,0), Base::Vector3d(0,0,-1), Base::Vector3d(-1,0,0) );
addRotItem(cl);
cl = configLine( 7 , "BD", Base::Vector3d(1,0,0), Base::Vector3d(1,0,0), Base::Vector3d(0,0,1),
Base::Vector3d(-1,0,0), Base::Vector3d(0,0,-1), Base::Vector3d(1,0,0) );
addRotItem(cl);
cl = configLine( 8 , "BF", Base::Vector3d(-1,0,0), Base::Vector3d(0,-1,0), Base::Vector3d(0,0,1),
Base::Vector3d(0,1,0), Base::Vector3d(0,0,-1), Base::Vector3d(0,1,0) );
addRotItem(cl);
cl = configLine( 9 , "CA", Base::Vector3d(0,1,0), Base::Vector3d(1,0,0), Base::Vector3d(-1,0,0),
Base::Vector3d(1,0,0), Base::Vector3d(0,1,0), Base::Vector3d(0,1,0) );
addRotItem(cl);
cl = configLine( 10 , "CB", Base::Vector3d(0,0,1), Base::Vector3d(0,0,1), Base::Vector3d(-1,0,0),
Base::Vector3d(0,0,-1), Base::Vector3d(1,0,0), Base::Vector3d(0,0,1) );
addRotItem(cl);
cl = configLine( 11 , "CE", Base::Vector3d(0,0,-1), Base::Vector3d(0,0,-1), Base::Vector3d(-1,0,0),
Base::Vector3d(0,0,1), Base::Vector3d(1,0,0), Base::Vector3d(0,0,-1) );
addRotItem(cl);
cl = configLine( 12 , "CF", Base::Vector3d(0,-1,0), Base::Vector3d(0,-1,0), Base::Vector3d(-1,0,0),
Base::Vector3d(0,1,0), Base::Vector3d(1,0,0), Base::Vector3d(0,-1,0) );
addRotItem(cl);
cl = configLine( 13 , "DA", Base::Vector3d(0,1,0), Base::Vector3d(0,1,0), Base::Vector3d(1,0,0),
Base::Vector3d(0,-1,0), Base::Vector3d(-1,0,0), Base::Vector3d(0,1,0) );
addRotItem(cl);
cl = configLine( 14 , "DB", Base::Vector3d(0,0,1), Base::Vector3d(0,0,1), Base::Vector3d(1,0,0),
Base::Vector3d(0,0,-1), Base::Vector3d(-1,0,0), Base::Vector3d(0,0,1) );
addRotItem(cl);
cl = configLine( 15 , "DE", Base::Vector3d(0,0,-1), Base::Vector3d(0,0,-1), Base::Vector3d(1,0,0),
Base::Vector3d(0,0,1), Base::Vector3d(-1,0,0), Base::Vector3d(0,0,-1) );
addRotItem(cl);
cl = configLine( 16 , "DF", Base::Vector3d(0,-1,0), Base::Vector3d(-1,0,0), Base::Vector3d(1,0,0),
Base::Vector3d(1,0,0), Base::Vector3d(0,-1,0), Base::Vector3d(0,-1,0) );
addRotItem(cl);
cl = configLine( 17 , "EA", Base::Vector3d(0,1,0), Base::Vector3d(0,1,0), Base::Vector3d(0,0,-1),
Base::Vector3d(0,-1,0), Base::Vector3d(0,0,1), Base::Vector3d(0,1,0) );
addRotItem(cl);
cl = configLine( 18 , "EC", Base::Vector3d(-1,0,0), Base::Vector3d(-1,0,0), Base::Vector3d(0,0,-1),
Base::Vector3d(1,0,0), Base::Vector3d(0,0,1), Base::Vector3d(-1,0,0) );
addRotItem(cl);
cl = configLine( 19 , "ED", Base::Vector3d(1,0,0), Base::Vector3d(1,0,0), Base::Vector3d(0,0,-1),
Base::Vector3d(-1,0,0), Base::Vector3d(0,0,1), Base::Vector3d(1,0,0) );
addRotItem(cl);
cl = configLine( 20 , "EF", Base::Vector3d(0,-1,0), Base::Vector3d(0,-1,0), Base::Vector3d(0,0,-1),
Base::Vector3d(0,1,0), Base::Vector3d(0,0,1), Base::Vector3d(-1,0,0) );
addRotItem(cl);
cl = configLine( 21 , "FB", Base::Vector3d(0,0,1), Base::Vector3d(0,0,1), Base::Vector3d(0,-1,0),
Base::Vector3d(0,0,-1), Base::Vector3d(0,1,0), Base::Vector3d(0,0,1) );
addRotItem(cl);
cl = configLine( 22 , "FC", Base::Vector3d(-1,0,0), Base::Vector3d(0,1,0), Base::Vector3d(-1,0,0),
Base::Vector3d(1,0,0), Base::Vector3d(0,1,0), Base::Vector3d(-1,0,0) );
addRotItem(cl);
cl = configLine( 23 , "FD", Base::Vector3d(1,0,0), Base::Vector3d(1,0,0), Base::Vector3d(0,-1,0),
Base::Vector3d(-1,0,0), Base::Vector3d(0,1,0), Base::Vector3d(1,0,0) );
addRotItem(cl);
cl = configLine( 24 , "FE", Base::Vector3d(0,0,-1), Base::Vector3d(0,0,-1), Base::Vector3d(0,-1,0),
Base::Vector3d(0,0,1), Base::Vector3d(0,1,0), Base::Vector3d(0,0,-1) );
addRotItem(cl);
//Directions items
//#include "dirs.cpp"
// Dirs - b/f/l/k/r/t
cl = configLine( 1 , "AB", Base::Vector3d(1,0,0), Base::Vector3d(0,-1,0), Base::Vector3d(0,0,-1),
Base::Vector3d(0,1,0), Base::Vector3d(0,0,1), Base::Vector3d(-1,0,0) );
addDirItem(cl);
cl = configLine( 2 , "AC", Base::Vector3d(0,0,1), Base::Vector3d(0,-1,0), Base::Vector3d(1,0,0),
Base::Vector3d(0,1,0), Base::Vector3d(-1,0,0), Base::Vector3d(0,0,-1) );
addDirItem(cl);
cl = configLine( 3 , "AD", Base::Vector3d(0,0,-1), Base::Vector3d(0,-1,0), Base::Vector3d(-1,0,0),
Base::Vector3d(0,1,0), Base::Vector3d(1,0,0), Base::Vector3d(0,0,1) );
addDirItem(cl);
cl = configLine( 4 , "AE", Base::Vector3d(-1,0,0), Base::Vector3d(0,-1,0), Base::Vector3d(0,0,1),
Base::Vector3d(0,1,0), Base::Vector3d(0,0,-1), Base::Vector3d(1,0,0) );
addDirItem(cl);
cl = configLine( 5 , "BA", Base::Vector3d(-1,0,0), Base::Vector3d(0,0,1), Base::Vector3d(0,1,0),
Base::Vector3d(0,0,-1), Base::Vector3d(0,-1,0), Base::Vector3d(1,0,0) );
addDirItem(cl);
//BC = FBDECA
cl = configLine( 6 , "BC", Base::Vector3d(0,1,0), Base::Vector3d(0,0,1), Base::Vector3d(1,0,0),
Base::Vector3d(0,0,-1), Base::Vector3d(-1,0,0), Base::Vector3d(0,-1,0) );
addDirItem(cl);
cl = configLine( 7 , "BD", Base::Vector3d(0,-1,0), Base::Vector3d(0,0,1), Base::Vector3d(-1,0,0),
Base::Vector3d(0,0,-1), Base::Vector3d(1,0,0), Base::Vector3d(0,1,0) );
addDirItem(cl);
cl = configLine( 8 , "BF", Base::Vector3d(1,0,0), Base::Vector3d(0,0,1), Base::Vector3d(0,-1,0),
Base::Vector3d(0,0,-1), Base::Vector3d(0,1,0), Base::Vector3d(-1,0,0) );
addDirItem(cl);
cl = configLine( 9 , "CA", Base::Vector3d(0,0,-1), Base::Vector3d(-1,0,0), Base::Vector3d(0,1,0),
Base::Vector3d(1,0,0), Base::Vector3d(0,-1,0), Base::Vector3d(0,0,1) );
addDirItem(cl);
cl = configLine( 10 , "CB", Base::Vector3d(0,-1,0), Base::Vector3d(-1,0,0), Base::Vector3d(0,0,-1),
Base::Vector3d(1,0,0), Base::Vector3d(0,0,1), Base::Vector3d(0,1,0) );
addDirItem(cl);
cl = configLine( 11 , "CE", Base::Vector3d(0,1,0), Base::Vector3d(-1,0,0), Base::Vector3d(0,0,1),
Base::Vector3d(1,0,0), Base::Vector3d(0,0,-1), Base::Vector3d(0,-1,0) );
addDirItem(cl);
cl = configLine( 12 , "CF", Base::Vector3d(0,0,1), Base::Vector3d(-1,0,0), Base::Vector3d(0,-1,0),
Base::Vector3d(1,0,0), Base::Vector3d(0,1,0), Base::Vector3d(0,0,-1) );
addDirItem(cl);
cl = configLine( 13 , "DA", Base::Vector3d(0,0,1), Base::Vector3d(1,0,0), Base::Vector3d(0,1,0),
Base::Vector3d(-1,0,0), Base::Vector3d(0,-1,0), Base::Vector3d(0,0,-1) );
addDirItem(cl);
cl = configLine( 14 , "DB", Base::Vector3d(0,1,0), Base::Vector3d(1,0,0), Base::Vector3d(0,0,-1),
Base::Vector3d(-1,0,0), Base::Vector3d(0,0,1), Base::Vector3d(0,-1,0) );
addDirItem(cl);
cl = configLine( 15 , "DE", Base::Vector3d(0,-1,0), Base::Vector3d(1,0,0), Base::Vector3d(0,0,1),
Base::Vector3d(-1,0,0), Base::Vector3d(0,0,-1), Base::Vector3d(0,1,0) );
addDirItem(cl);
cl = configLine( 16 , "DF", Base::Vector3d(0,0,-1), Base::Vector3d(1,0,0), Base::Vector3d(0,-1,0),
Base::Vector3d(-1,0,0), Base::Vector3d(0,1,0), Base::Vector3d(0,0,1) );
addDirItem(cl);
cl = configLine( 17 , "EA", Base::Vector3d(1,0,0), Base::Vector3d(0,0,-1), Base::Vector3d(0,1,0),
Base::Vector3d(0,0,1), Base::Vector3d(0,-1,0), Base::Vector3d(-1,0,0) );
addDirItem(cl);
cl = configLine( 18 , "EC", Base::Vector3d(0,-1,0), Base::Vector3d(0,0,-1), Base::Vector3d(1,0,0),
Base::Vector3d(0,0,1), Base::Vector3d(-1,0,0), Base::Vector3d(0,1,0) );
addDirItem(cl);
cl = configLine( 19 , "ED", Base::Vector3d(0,1,0), Base::Vector3d(0,0,-1), Base::Vector3d(-1,0,0),
Base::Vector3d(0,0,1), Base::Vector3d(1,0,0), Base::Vector3d(0,-1,0) );
addDirItem(cl);
cl = configLine( 20 , "EF", Base::Vector3d(-1,0,0), Base::Vector3d(0,0,-1), Base::Vector3d(0,-1,0),
Base::Vector3d(0,0,1), Base::Vector3d(0,1,0), Base::Vector3d(1,0,0) );
addDirItem(cl);
cl = configLine( 21 , "FB", Base::Vector3d(-1,0,0), Base::Vector3d(0,1,0), Base::Vector3d(0,0,-1),
Base::Vector3d(0,-1,0), Base::Vector3d(0,0,1), Base::Vector3d(1,0,0) );
addDirItem(cl);
cl = configLine( 22 , "FC", Base::Vector3d(0,0,-1), Base::Vector3d(0,1,0), Base::Vector3d(1,0,0),
Base::Vector3d(0,-1,0), Base::Vector3d(-1,0,0), Base::Vector3d(0,0,1) );
addDirItem(cl);
cl = configLine( 23 , "FD", Base::Vector3d(0,0,1), Base::Vector3d(0,1,0), Base::Vector3d(-1,0,0),
Base::Vector3d(0,-1,0), Base::Vector3d(1,0,0), Base::Vector3d(0,0,-1) );
addDirItem(cl);
cl = configLine( 24 , "FE", Base::Vector3d(1,0,0), Base::Vector3d(0,1,0), Base::Vector3d(0,0,1),
Base::Vector3d(0,-1,0), Base::Vector3d(0,0,-1), Base::Vector3d(-1,0,0) );
addDirItem(cl);
}
void configTable::dump(char* title)

243
src/Mod/TechDraw/App/DrawProjGroup.cpp
View File

@ -53,6 +53,7 @@ const char* DrawProjGroup::ProjectionTypeEnums[] = {"Default",
"Third Angle",
NULL};
//default starting dirs & rots
const std::map<std::string,Base::Vector3d> DrawProjGroup::m_frameToStdDir = {
{ "Front", Base::Vector3d(0, -1, 0) }, //front
{ "Rear", Base::Vector3d(0, 1, 0) }, //rear
@ -60,27 +61,26 @@ const std::map<std::string,Base::Vector3d> DrawProjGroup::m_frameToStdDir = {
{ "Left", Base::Vector3d(-1, 0, 0) }, //left
{ "Top", Base::Vector3d(0, 0, 1) }, //top
{ "Bottom", Base::Vector3d(0, 0, -1) }, //bottom
{ "FrontBottomLeft", Base::Vector3d(-1, -1, -1) }, //FBL
{ "FrontBottomLeft", Base::Vector3d(-1, -1, -1) }, //FBL
{ "FrontBottomRight", Base::Vector3d(1, -1, -1) }, //FBR
{ "FrontTopLeft", Base::Vector3d(-1,-1,1) }, //FTL
{ "FrontTopRight", Base::Vector3d(1, -1, 1) } //FTR
{ "FrontTopRight", Base::Vector3d(1, -1, 1) } //FTR
};
const std::map<std::string,Base::Vector3d> DrawProjGroup::m_frameToStdRot = {
{ "Front", Base::Vector3d(1, 0, 0) }, //front
{ "Rear", Base::Vector3d(-1, 0, 0) }, //rear
{ "Right", Base::Vector3d(0, -1, 0) }, //right this makes the first rendering correct, but
{ "Left", Base::Vector3d(0, 1, 0) }, //left every 2nd subsequent rendering upside down (ie cube is incorrect)
// { "Right", Base::Vector3d(0, 1, 0) }, //right this makes the first rendering upside down
// { "Left", Base::Vector3d(0, -1, 0) }, /left but subsequent renderings right side up (ie cube is correct)
{ "Right", Base::Vector3d(0, -1, 0) }, //right
{ "Left", Base::Vector3d(0, 1, 0) }, //left
{ "Top", Base::Vector3d(1, 0, 0) }, //top
{ "Bottom", Base::Vector3d(1, 0, 0) }, //bottom
{ "FrontBottomLeft", Base::Vector3d(2, -1, 0.5) }, //FBL LFB
{ "FrontBottomRight", Base::Vector3d(2, -1, -0.5) }, //FBR RFB
{ "FrontTopLeft", Base::Vector3d(2, -1, -0.5) }, //FTL LFT
{ "FrontTopRight", Base::Vector3d(2, 1, 0.5) } //FTR RFT
{ "FrontBottomLeft", Base::Vector3d(2, 1, 0.5) },
{ "FrontBottomRight", Base::Vector3d(2, -1, -0.5) },
{ "FrontTopLeft", Base::Vector3d(2, 1, -0.5) },
{ "FrontTopRight", Base::Vector3d(2, -1, 0.5) }
};
//one of these is obs??
// map of front.dir+front.rot onto config
const std::map<std::string,std::string> DrawProjGroup::m_dirRotToConfig = {
{"AB","AB"},
@ -171,7 +171,7 @@ DrawProjGroup::~DrawProjGroup()
void DrawProjGroup::onChanged(const App::Property* prop)
{
//TODO: For some reason, when the projection type is changed, the isometric views show change appropriately, but the orthographic ones dont... Or vice-versa. why would you change from 1st to 3rd in mid drawing?
//TODO: For some reason, when the projection type is changed, the isometric views show change appropriately, but the orthographic ones dont... Or vice-versa. WF: why would you change from 1st to 3rd in mid drawing?
//if group hasn't been added to page yet, can't scale or distribute projItems
TechDraw::DrawPage *page = getPage();
if (!isRestoring() && page) {
@ -441,7 +441,6 @@ bool DrawProjGroup::hasProjection(const char *viewProjType) const
App::DocumentObject * DrawProjGroup::addProjection(const char *viewProjType)
{
//Base::Console().Message("TRACE - DPG::addProjection(%s)\n",viewProjType);
//if this is the first Projection added, it should automatically be the Anchor/front view
// or if viewProjType == "Front" Anchor.setValue(view)
DrawProjGroupItem *view( nullptr );
@ -466,9 +465,12 @@ App::DocumentObject * DrawProjGroup::addProjection(const char *viewProjType)
Anchor.setValue(docObj);
view->Direction.setValue(m_frameToStdDir.at("Front")); //just (Base::Vector3d(0.0,-1.0,0.0))
view->OrientBasis.setValue(m_frameToStdRot.at("Front"));
//view->recomputeFeature();
} else {
//really need to check with Cube to get current dir & rot
//TODO: really need to check with Cube to get current dir & rot this uses initial values from table
//if (DPGI(front) and DPGI(right) exist) config = front.face + right.face
//
//else
// use start up values (m_frameToStdDir/m_frameToStdRot)
view->Direction.setValue(m_frameToStdDir.at(viewProjType));
view->OrientBasis.setValue(m_frameToStdRot.at(viewProjType));
}
@ -478,7 +480,6 @@ App::DocumentObject * DrawProjGroup::addProjection(const char *viewProjType)
view->recomputeFeature();
}
Base::Console().Message("TRACE - DPG::addProjection exits\n");
return view;
}
@ -539,13 +540,14 @@ void DrawProjGroup::arrangeViewPointers(DrawProjGroupItem *viewPtrs[10]) const
// Iterate through views and populate viewPtrs
if ( strcmp(projType, "Third Angle") == 0 ||
strcmp(projType, "First Angle") == 0 ) {
// Third Angle: FTL T FTRight
// L F Right Rear
// FBL B FBRight
// Third Angle: FTL T FTRight 0 1 2
// L F Right Rear 3 4 5 6
// FBL B FBRight 7 8 9
//
// First Angle: FBRight B FBL
// Right F L Rear
// FTRight T FTL
// First Angle: FBRight B FBL 0 1 2
// Right F L Rear 3 4 5 6
// FTRight T FTL 7 8 9
bool thirdAngle = (strcmp(projType, "Third Angle") == 0);
for (auto it : Views.getValues()) {
auto oView( dynamic_cast<DrawProjGroupItem *>(it) );
@ -606,6 +608,7 @@ void DrawProjGroup::makeViewBbs(DrawProjGroupItem *viewPtrs[10],
bool DrawProjGroup::distributeProjections()
{
//TODO: bounding boxes do not take view orientation into account
// ie X&Y widths might be swapped on page
if (!AutoDistribute.getValue()) {
return true;
}
@ -623,70 +626,84 @@ bool DrawProjGroup::distributeProjections()
Base::BoundBox3d bboxes[10];
makeViewBbs(viewPtrs, bboxes);
// Now that things are setup, do the spacing
double scale = Scale.getValue();
if (scale < 1.0) scale = 1.0;
double xSpacing = scale * spacingX.getValue(); //in mm
double ySpacing = scale * spacingY.getValue(); //in mm
double xSpacing = spacingX.getValue(); //in mm/scale
double ySpacing = spacingY.getValue(); //in mm/scale
double bigRow = 0.0;
double bigCol = 0.0;
for (auto& b: bboxes) {
if (!b.IsValid()) {
continue;
}
if (b.LengthX() > bigCol) {
bigCol = b.LengthX();
}
if (b.LengthY() > bigRow) {
bigRow = b.LengthY();
}
}
//if we have iso's, make sure they fit the grid.
if (viewPtrs[0] || viewPtrs[2] || viewPtrs[7] || viewPtrs[9]) {
bigCol = std::max(bigCol,bigRow);
bigRow = bigCol;
}
//viewPtrs
// 0 1 2
// 3 4 5 6
// 7 8 9
if (viewPtrs[0] && viewPtrs[0]->allowAutoPos() &&
bboxes[0].IsValid()) {
double displace = std::max(bboxes[0].LengthX() + bboxes[4].LengthX(),
bboxes[0].LengthY() + bboxes[4].LengthY());
viewPtrs[0]->X.setValue(displace / -2.0 - xSpacing);
viewPtrs[0]->Y.setValue(displace / 2.0 + ySpacing);
viewPtrs[0]->X.setValue(-bigCol - xSpacing);
viewPtrs[0]->Y.setValue(bigRow + ySpacing);
}
if (viewPtrs[1] && viewPtrs[1]->allowAutoPos() &&
bboxes[1].IsValid()) {
viewPtrs[1]->Y.setValue((bboxes[1].LengthY() + bboxes[4].LengthY()) / 2.0 + ySpacing);
viewPtrs[1]->Y.setValue(bigRow + ySpacing);
}
if (viewPtrs[2] && viewPtrs[2]->allowAutoPos()
) {
double displace = std::max(bboxes[2].LengthX() + bboxes[4].LengthX(),
bboxes[2].LengthY() + bboxes[4].LengthY());
viewPtrs[2]->X.setValue(displace / 2.0 + xSpacing);
viewPtrs[2]->Y.setValue(displace / 2.0 + ySpacing);
viewPtrs[2]->X.setValue(bigCol + xSpacing);
viewPtrs[2]->Y.setValue(bigRow + ySpacing);
}
if (viewPtrs[3] && viewPtrs[3]->allowAutoPos() &&
bboxes[3].IsValid() &&
bboxes[4].IsValid()) {
viewPtrs[3]->X.setValue((bboxes[3].LengthX() + bboxes[4].LengthX()) / -2.0 - xSpacing);
viewPtrs[3]->X.setValue(-bigCol - xSpacing);
}
if (viewPtrs[4]) { // TODO: Move this check above, and figure out a sane bounding box based on other existing views
}
if (viewPtrs[5] && viewPtrs[5]->allowAutoPos() &&
bboxes[5].IsValid() &&
bboxes[4].IsValid()) {
viewPtrs[5]->X.setValue((bboxes[5].LengthX() + bboxes[4].LengthX()) / 2.0 + xSpacing);
viewPtrs[5]->X.setValue(bigCol + xSpacing);
}
if (viewPtrs[6] && viewPtrs[6]->allowAutoPos() &&
bboxes[6].IsValid()) { //"Rear"
if (viewPtrs[5] &&
bboxes[5].IsValid()) {
viewPtrs[6]->X.setValue(viewPtrs[5]->X.getValue() + bboxes[5].LengthX()/2.0 + xSpacing + bboxes[6].LengthX() / 2.0 );
viewPtrs[6]->X.setValue(viewPtrs[5]->X.getValue() + bigCol + xSpacing);
}else if (viewPtrs[4] &&
bboxes[4].IsValid()) {
viewPtrs[6]->X.setValue((bboxes[6].LengthX() + bboxes[4].LengthX()) / 2.0 + xSpacing);
viewPtrs[6]->X.setValue(bigCol + xSpacing);
}
}
if (viewPtrs[7] && viewPtrs[7]->allowAutoPos() &&
bboxes[7].IsValid()) {
double displace = std::max(bboxes[7].LengthX() + bboxes[4].LengthX(),
bboxes[7].LengthY() + bboxes[4].LengthY());
viewPtrs[7]->X.setValue(displace / -2.0 - xSpacing);
viewPtrs[7]->Y.setValue(displace / -2.0 - ySpacing);
viewPtrs[7]->X.setValue(-bigCol - xSpacing);
viewPtrs[7]->Y.setValue(-bigRow - ySpacing);
}
if (viewPtrs[8] && viewPtrs[8]->allowAutoPos() &&
bboxes[8].IsValid() &&
bboxes[4].IsValid()) {
viewPtrs[8]->Y.setValue((bboxes[8].LengthY() + bboxes[4].LengthY()) / -2.0 - ySpacing);
viewPtrs[8]->Y.setValue(-bigRow - ySpacing);
}
if (viewPtrs[9] && viewPtrs[9]->allowAutoPos() &&
bboxes[9].IsValid()) {
double displace = std::max(bboxes[9].LengthX() + bboxes[4].LengthX(),
bboxes[9].LengthY() + bboxes[4].LengthY());
viewPtrs[9]->X.setValue(displace / 2.0 + xSpacing);
viewPtrs[9]->Y.setValue(displace / -2.0 - ySpacing);
viewPtrs[9]->X.setValue(bigCol + xSpacing);
viewPtrs[9]->Y.setValue(-bigRow - ySpacing);
}
return true;
@ -782,12 +799,11 @@ bool DrawProjGroup::hasAnchor(void)
TechDraw::DrawProjGroupItem* DrawProjGroup::getAnchor(void)
{
// Base::Console().Message("TRACE - DPG::getAnchor() - %s\n",getNameInDocument());
DrawProjGroupItem* result = nullptr;
App::DocumentObject* docObj = Anchor.getValue();
if (docObj == nullptr) {
//explode! DPG w/o anchor
Base::Console().Message("TRACE - DPG::getAnchor - DPG has no Anchor!!!\n");
Base::Console().Error("Error - DPG::getAnchor - DPG has no Anchor!!!\n");
} else {
result = static_cast<DrawProjGroupItem*>(docObj);
}
@ -822,7 +838,6 @@ Base::Vector3d DrawProjGroup::getAnchorDirection(void)
void DrawProjGroup::updateSecondaryDirs()
{
// Base::Console().Message("TRACE - DPG::updateSecondaryDirs() - %s\n",getNameInDocument());
for (auto& docObj: Views.getValues()) {
Base::Vector3d newDir;
Base::Vector3d newAxis;
@ -891,88 +906,75 @@ void DrawProjGroup::updateSecondaryDirs()
v->OrientBasis.setValue(newAxis);
v->recomputeFeature();
}
// Base::Console().Message("TRACE - DPG::updateSecondaryDirs exits\n");
}
void DrawProjGroup::rotateRight()
{
//Front -> Right -> Rear -> Left -> Front
//m_cube->dump("TRACE - DPG::rotR before");
m_cube->rotateRight();
//m_cube->dump("TRACE - DPG::rotR after");
updateSecondaryDirs();
}
void DrawProjGroup::rotateLeft()
{
//Front -> Left -> Rear -> Right -> Front
//m_cube->dump("TRACE - DPG::rotL before");
m_cube->rotateLeft();
//m_cube->dump("TRACE - DPG::rotL after");
updateSecondaryDirs();
}
void DrawProjGroup::rotateUp()
{
//Front -> Top -> Rear -> Bottom -> Front
//m_cube->dump("TRACE - DPG::rotU before");
m_cube->rotateUp();
//m_cube->dump("TRACE - DPG::rotU after");
updateSecondaryDirs();
}
void DrawProjGroup::rotateDown()
{
//Front -> Bottom -> Rear -> Top -> Front
m_cube->dump("TRACE - DPG::rotD before");
m_cube->rotateDown();
m_cube->dump("TRACE - DPG::rotD after");
updateSecondaryDirs();
}
void DrawProjGroup::spinCW()
{
//Top -> Right -> Bottom -> Left -> Top
//m_cube->dump("TRACE - DPG::spinCW before");
m_cube->spinCW();
//m_cube->dump("TRACE - DPG::spinCW after");
updateSecondaryDirs();
}
void DrawProjGroup::spinCCW()
{
//Top -> Left -> Bottom -> Right -> Top
//m_cube->dump("TRACE - DPG::spingCCW before");
m_cube->spinCCW();
//m_cube->dump("TRACE - DPG::spinCCW after");
updateSecondaryDirs();
}
// find a config with Dir as Front view and Up as Top view
// used in setting view to match OpenInventor
void DrawProjGroup::setTable(Base::Vector3d dir, Base::Vector3d up)
{
std::string viewFront = Cube::dirToView(dir); //convert to closest basis vector
std::string viewUp = Cube::dirToView(up); //convert to closest basis vector
std::string viewUp = Cube::dirToView(up); //convert to closest basis vector
std::string altKey = viewFront + viewUp;
std::string config;
Base::Console().Message("TRACE - DPG::setTable - using altKey: %s\n", altKey.c_str());
try {
config = m_frontTopToConfig.at(altKey);
}
// catch (const std::out_of_range& oor) {
// std::cerr << "Out of Range error: " << oor.what() << '\n';
// }
catch (...) {
Base::Console().Error("Error - DPG::setTable - no match for alt config: %s\n",altKey.c_str());
catch (const std::out_of_range& oor) {
Base::Console().Error("Error - DPG::setTable - no match for alt config: %s - %s\n",altKey.c_str(),oor.what());
return;
}
Base::Console().Message("TRACE - DPG::setTable - found config: %s **\n",config.c_str());
m_cube->updateDirsToConfig(config);
m_cube->updateRotsToConfig(config);
updateSecondaryDirs();
setConfig(config);
}
// set config to a specific value
void DrawProjGroup::setConfig(std::string cfg)
{
m_cube->updateDirsToConfig(cfg);
m_cube->updateRotsToConfig(cfg);
updateSecondaryDirs();
}
void DrawProjGroup::resetTable(void)
@ -988,56 +990,55 @@ void DrawProjGroup::resetTable(void)
updateSecondaryDirs();
}
//dumps the current iso DPGI's
void DrawProjGroup::dumpISO(char * title)
{
//FBL/FBR/FTL/FTR
//
Base::Console().Message("DPG ISO: %s\n", title);
for (auto& docObj: Views.getValues()) {
Base::Vector3d dir;
Base::Vector3d axis;
DrawProjGroupItem* v = static_cast<DrawProjGroupItem*>(docObj);
std::string t = v->Type.getValueAsString();
dir = v->Direction.getValue();
axis = v->OrientBasis.getValue();
Base::Console().Message("%s: %s/%s\n",
t.c_str(),DrawUtil::formatVector(dir).c_str(),DrawUtil::formatVector(axis).c_str());
}
}
//*************************************
//obs??
//! rebuild view direction map from existing DPGI's if possible or from Anchor
//! rebuild view direction map from existing DPGI's
void DrawProjGroup::onDocumentRestored()
{
// Base::Vector3d f,r,t;
// Base::Vector3d fr,rr,tr;
// bool ffound = false;
// bool rfound = false;
// bool tfound = false;
//
// for (auto& docObj: Views.getValues()) {
// DrawProjGroupItem* v = static_cast<DrawProjGroupItem*>(docObj);
// ProjItemType type = static_cast<ProjItemType>(v->Type.getValue());
// switch (type) {
// case Front : {
// f = v->Direction.getValue();
// fr = v->OrientBasis.getValue();
// ffound = true;
// break;
// }
// case Right : {
// r = v->Direction.getValue();
// rr = v->OrientBasis.getValue();
// rfound = true;
// break;
// }
// case Top : {
// t = v->Direction.getValue();
// tr = v->OrientBasis.getValue();
// tfound = true;
// break;
// }
// default: {
// break;
// }
// }
// }
// if (ffound && rfound && tfound) {
// //m_cube->reinit(r,rr,f,fr,t,tr);
// Base::Console().Log("LOG: - DPG::restore - found Right,Front,Top\n");
// } else {
// m_cube->initialize(r,f,t);
// Base::Console().Log("LOG: - DPG::restore - didn't find Right,Front,Top\n");
// }
// DrawViewCollection::onDocumentRestored();
if (hasProjection("Front") && hasProjection("Right")) {
Base::Vector3d dirFront = getProjItem("Front")->Direction.getValue();
std::string viewFront = Cube::dirToView(dirFront);
Base::Vector3d dirRight = getProjItem("Right")->Direction.getValue();
std::string viewRight = Cube::dirToView(dirRight);
std::string config = viewFront + viewRight;
setConfig(config);
} else if (hasProjection("Front")) {
Base::Vector3d dirFront = getProjItem("Front")->Direction.getValue();
std::string viewDir = Cube::dirToView(dirFront);
Base::Vector3d rotFront = getProjItem("Rot")->OrientBasis.getValue();
std::string viewRot = Cube::dirToView(rotFront);
std::string config = viewDir + viewRot;
//find(config) or try/catch
try {
config = m_dirRotToConfig.at(config);
setConfig(config);
}
catch (...) {
Base::Console().Message("ERROR: DPG cannot set configuration: %s using AD\n",config.c_str());
setConfig("AD");
}
} else {
Base::Console().Message("ERROR: DPG cannot find Front view on restore\n");
setConfig("AD"); // set to default config??
}
}
PyObject *DrawProjGroup::getPyObject(void)

2
src/Mod/TechDraw/App/DrawProjGroup.h
View File

@ -127,7 +127,9 @@ public:
void spinCCW(void);
void setTable(Base::Vector3d dir, Base::Vector3d rot);
void setConfig(std::string cfg);
void resetTable(void);
void dumpISO(char * title);
protected:
void onChanged(const App::Property* prop);

42
src/Mod/TechDraw/App/DrawProjGroupItem.cpp
View File

@ -87,25 +87,6 @@ short DrawProjGroupItem::mustExecute() const
void DrawProjGroupItem::onChanged(const App::Property *prop)
{
// //TODO: too many executes!
// //TODO: Should we allow changes to the Type here? Seems that should be handled through DrawProjGroup
// if (!isRestoring()) {
//// //Base::Console().Message("TRACE - DPGI::onChanged(%s) - %s/%s\n",prop->getName(),getNameInDocument(),Label.getValue());
// if (prop == &Type && Type.isTouched()) {
//// //Base::Console().Message("TRACE - DPGI::onChanged(%s) - Type: %s\n",prop->getName(),Type.getValueAsString());
//// execute();
// } else if (prop == &Direction) {
// if (getGroup() != nullptr) {
// OrientBasis.setValue(getGroup()->getXAxisDir(Type.getValueAsString()));
// Base::Console().Message("TRACE - DPGI::onChanged(%s) - Direction: %s Orient: %s\n",
// prop->getName(),DrawUtil::formatVector(Direction.getValue()).c_str(),
// DrawUtil::formatVector(OrientBasis.getValue()).c_str());
// }
// }
//// execute();
//// } //else if (prop == &OrientBasis) { //don't want to do twice though!
// }
TechDraw::DrawViewPart::onChanged(prop);
}
@ -139,36 +120,25 @@ gp_Ax2 DrawProjGroupItem::getViewAxis(const Base::Vector3d& pt,
const Base::Vector3d& axis,
const bool flip) const
{
// Base::Console().Message("TRACE - DPGI::getViewAxis - %s/%s - Type: %s\n",getNameInDocument(),Label.getValue(),Type.getValueAsString());
gp_Ax2 viewAxis;
Base::Vector3d x = OrientBasis.getValue();
Base::Vector3d nx = x;
x.Normalize();
Base::Vector3d na = axis;
na.Normalize();
// Base::Console().Message("TRACE - DPGI::getViewAxis - axis: %s orient: %s\n",
// DrawUtil::formatVector(axis).c_str(),DrawUtil::formatVector(x).c_str());
if (DrawUtil::checkParallel(nx,na)) { //parallel/antiparallel
// Base::Console().Message("TRACE - DPGI::getViewAxis - parallel flip: %d\n",flip);
viewAxis = TechDrawGeometry::getViewAxis(pt,axis,flip); //use default orientation
} else {
//Base::Console().Message("TRACE - DPGI::getViewAxis - skew flip: %d\n",flip);
// if (Type.isValue("Right") || Type.isValue("Left")) { //no difference with incorrect initial axis
// viewAxis = TechDrawGeometry::getViewAxis(pt,axis,x,!flip); //no difference with correct initial axis!!
// } else {
viewAxis = TechDrawGeometry::getViewAxis(pt,axis,x,flip);
// }
viewAxis = TechDrawGeometry::getViewAxis(pt,axis,x,flip);
}
//Base::Console().Message("TRACE - DPGI::getViewAxis exits\n");
return viewAxis;
}
//! rotate OrientBasis by angle radians around view Direction
Base::Vector3d DrawProjGroupItem::rotated(const double angle)
{
Base::Console().Message("TRACE - DPGI::rotated - %s/%s angle: %.3f\n",Label.getValue(),Type.getValueAsString(),angle);
Base::Vector3d line = Direction.getValue();
Base::Vector3d oldBasis = OrientBasis.getValue();
Base::Vector3d newBasis;
@ -176,16 +146,6 @@ Base::Vector3d DrawProjGroupItem::rotated(const double angle)
Base::Matrix4D xForm;
xForm.rotLine(line,angle);
newBasis = xForm * (oldBasis);
Base::Console().Message("TRACE - DPGI::rotated - line: %s old: %s new: %s\n",
DrawUtil::formatVector(line).c_str(),
DrawUtil::formatVector(oldBasis).c_str(),
DrawUtil::formatVector(newBasis).c_str());
// if (getGroup() != nullptr) {
// if (getGroup()->getException(Type.getValueAsString())) {
// newBasis = newBasis * -1.0;
// Base::Console().Message("TRACE - DPGI::rotated - EXCEPTION\n");
// }
// }
return newBasis;
}

43
src/Mod/TechDraw/App/DrawUtil.cpp
View File

@ -344,6 +344,49 @@ Base::Vector3d DrawUtil::vecRotate(Base::Vector3d vec,
return result;
}
Base::Vector3d DrawUtil::closestBasis(Base::Vector3d v)
{
Base::Vector3d result(0.0,-1,0);
Base::Vector3d stdX(1.0,0.0,0.0);
Base::Vector3d stdY(0.0,1.0,0.0);
Base::Vector3d stdZ(0.0,0.0,1.0);
Base::Vector3d stdXr(-1.0,0.0,0.0);
Base::Vector3d stdYr(0.0,-1.0,0.0);
Base::Vector3d stdZr(0.0,0.0,-1.0);
double angleX,angleY,angleZ,angleXr,angleYr,angleZr, angleMin;
angleX = stdX.GetAngle(v);
angleY = stdY.GetAngle(v);
angleZ = stdZ.GetAngle(v);
angleXr = stdXr.GetAngle(v);
angleYr = stdYr.GetAngle(v);
angleZr = stdZr.GetAngle(v);
angleMin = angleX;
result = stdX;
if (angleY < angleMin) {
angleMin = angleY;
result = stdY;
}
if (angleZ < angleMin) {
angleMin = angleZ;
result = stdZ;
}
if (angleXr < angleMin) {
angleMin = angleXr;
result = stdXr;
}
if (angleYr < angleMin) {
angleMin = angleYr;
result = stdYr;
}
if (angleZr < angleMin) {
angleMin = angleZr;
result = stdZr;
}
return result;
}
//based on Function provided by Joe Dowsett, 2014
double DrawUtil::sensibleScale(double working_scale)
{

2
src/Mod/TechDraw/App/DrawUtil.h
View File

@ -67,6 +67,8 @@ class TechDrawExport DrawUtil {
double angle,
Base::Vector3d axis,
Base::Vector3d org = Base::Vector3d(0.0,0.0,0.0));
static Base::Vector3d closestBasis(Base::Vector3d v);
//debugging routines

75
src/Mod/TechDraw/App/dirs.cpp
View File

@ -1,75 +0,0 @@
// Dirs - b/f/l/k/r/t
cl = configLine( 1 , "AB", Base::Vector3d(1,0,0), Base::Vector3d(0,-1,0), Base::Vector3d(0,0,-1),
Base::Vector3d(0,1,0), Base::Vector3d(0,0,1), Base::Vector3d(-1,0,0) );
addDirItem(cl);
cl = configLine( 2 , "AC", Base::Vector3d(0,0,1), Base::Vector3d(0,-1,0), Base::Vector3d(1,0,0),
Base::Vector3d(0,1,0), Base::Vector3d(-1,0,0), Base::Vector3d(0,0,-1) );
addDirItem(cl);
cl = configLine( 3 , "AD", Base::Vector3d(0,0,-1), Base::Vector3d(0,-1,0), Base::Vector3d(-1,0,0),
Base::Vector3d(0,1,0), Base::Vector3d(1,0,0), Base::Vector3d(0,0,1) );
addDirItem(cl);
cl = configLine( 4 , "AE", Base::Vector3d(-1,0,0), Base::Vector3d(0,-1,0), Base::Vector3d(0,0,1),
Base::Vector3d(0,1,0), Base::Vector3d(0,0,-1), Base::Vector3d(1,0,0) );
addDirItem(cl);
cl = configLine( 5 , "BA", Base::Vector3d(-1,0,0), Base::Vector3d(0,0,1), Base::Vector3d(0,1,0),
Base::Vector3d(0,0,-1), Base::Vector3d(0,-1,0), Base::Vector3d(1,0,0) );
addDirItem(cl);
//BC = FBDECA
cl = configLine( 6 , "BC", Base::Vector3d(0,1,0), Base::Vector3d(0,0,1), Base::Vector3d(1,0,0),
Base::Vector3d(0,0,-1), Base::Vector3d(-1,0,0), Base::Vector3d(0,-1,0) );
addDirItem(cl);
cl = configLine( 7 , "BD", Base::Vector3d(0,-1,0), Base::Vector3d(0,0,1), Base::Vector3d(-1,0,0),
Base::Vector3d(0,0,-1), Base::Vector3d(1,0,0), Base::Vector3d(0,1,0) );
addDirItem(cl);
cl = configLine( 8 , "BF", Base::Vector3d(1,0,0), Base::Vector3d(0,0,1), Base::Vector3d(0,-1,0),
Base::Vector3d(0,0,-1), Base::Vector3d(0,1,0), Base::Vector3d(-1,0,0) );
addDirItem(cl);
cl = configLine( 9 , "CA", Base::Vector3d(0,0,-1), Base::Vector3d(-1,0,0), Base::Vector3d(0,1,0),
Base::Vector3d(1,0,0), Base::Vector3d(0,-1,0), Base::Vector3d(0,0,1) );
addDirItem(cl);
cl = configLine( 10 , "CB", Base::Vector3d(0,-1,0), Base::Vector3d(-1,0,0), Base::Vector3d(0,0,-1),
Base::Vector3d(1,0,0), Base::Vector3d(0,0,1), Base::Vector3d(0,1,0) );
addDirItem(cl);
cl = configLine( 11 , "CE", Base::Vector3d(0,1,0), Base::Vector3d(-1,0,0), Base::Vector3d(0,0,1),
Base::Vector3d(1,0,0), Base::Vector3d(0,0,-1), Base::Vector3d(0,-1,0) );
addDirItem(cl);
cl = configLine( 12 , "CF", Base::Vector3d(0,0,1), Base::Vector3d(-1,0,0), Base::Vector3d(0,-1,0),
Base::Vector3d(1,0,0), Base::Vector3d(0,1,0), Base::Vector3d(0,0,-1) );
addDirItem(cl);
cl = configLine( 13 , "DA", Base::Vector3d(0,0,1), Base::Vector3d(1,0,0), Base::Vector3d(0,1,0),
Base::Vector3d(-1,0,0), Base::Vector3d(0,-1,0), Base::Vector3d(0,0,-1) );
addDirItem(cl);
cl = configLine( 14 , "DB", Base::Vector3d(0,1,0), Base::Vector3d(1,0,0), Base::Vector3d(0,0,-1),
Base::Vector3d(-1,0,0), Base::Vector3d(0,0,1), Base::Vector3d(0,-1,0) );
addDirItem(cl);
cl = configLine( 15 , "DE", Base::Vector3d(0,-1,0), Base::Vector3d(1,0,0), Base::Vector3d(0,0,1),
Base::Vector3d(-1,0,0), Base::Vector3d(0,0,-1), Base::Vector3d(0,1,0) );
addDirItem(cl);
cl = configLine( 16 , "DF", Base::Vector3d(0,0,-1), Base::Vector3d(1,0,0), Base::Vector3d(0,-1,0),
Base::Vector3d(-1,0,0), Base::Vector3d(0,1,0), Base::Vector3d(0,0,1) );
addDirItem(cl);
cl = configLine( 17 , "EA", Base::Vector3d(1,0,0), Base::Vector3d(0,0,-1), Base::Vector3d(0,1,0),
Base::Vector3d(0,0,1), Base::Vector3d(0,-1,0), Base::Vector3d(-1,0,0) );
addDirItem(cl);
cl = configLine( 18 , "EC", Base::Vector3d(0,-1,0), Base::Vector3d(0,0,-1), Base::Vector3d(1,0,0),
Base::Vector3d(0,0,1), Base::Vector3d(-1,0,0), Base::Vector3d(0,1,0) );
addDirItem(cl);
cl = configLine( 19 , "ED", Base::Vector3d(0,1,0), Base::Vector3d(0,0,-1), Base::Vector3d(-1,0,0),
Base::Vector3d(0,0,1), Base::Vector3d(1,0,0), Base::Vector3d(0,-1,0) );
addDirItem(cl);
cl = configLine( 20 , "EF", Base::Vector3d(-1,0,0), Base::Vector3d(0,0,-1), Base::Vector3d(0,-1,0),
Base::Vector3d(0,0,1), Base::Vector3d(0,1,0), Base::Vector3d(1,0,0) );
addDirItem(cl);
cl = configLine( 21 , "FB", Base::Vector3d(-1,0,0), Base::Vector3d(0,1,0), Base::Vector3d(0,0,-1),
Base::Vector3d(0,-1,0), Base::Vector3d(0,0,1), Base::Vector3d(1,0,0) );
addDirItem(cl);
cl = configLine( 22 , "FC", Base::Vector3d(0,0,-1), Base::Vector3d(0,1,0), Base::Vector3d(1,0,0),
Base::Vector3d(0,-1,0), Base::Vector3d(-1,0,0), Base::Vector3d(0,0,1) );
addDirItem(cl);
cl = configLine( 23 , "FD", Base::Vector3d(0,0,1), Base::Vector3d(0,1,0), Base::Vector3d(-1,0,0),
Base::Vector3d(0,-1,0), Base::Vector3d(1,0,0), Base::Vector3d(0,0,-1) );
addDirItem(cl);
cl = configLine( 24 , "FE", Base::Vector3d(1,0,0), Base::Vector3d(0,1,0), Base::Vector3d(0,0,1),
Base::Vector3d(0,-1,0), Base::Vector3d(0,0,-1), Base::Vector3d(-1,0,0) );
addDirItem(cl);

73
src/Mod/TechDraw/App/rots.cpp
View File

@ -1,73 +0,0 @@
// Rots - b/f/l/k/r/t
cl = configLine( 1 , "AB", Base::Vector3d(0,0,1), Base::Vector3d(0,0,1), Base::Vector3d(0,1,0),
Base::Vector3d(0,0,-1), Base::Vector3d(0,-1,0), Base::Vector3d(0,0,1) );
addRotItem(cl);
cl = configLine( 2 , "AC", Base::Vector3d(-1,0,0), Base::Vector3d(-1,0,0), Base::Vector3d(0,1,0),
Base::Vector3d(1,0,0), Base::Vector3d(0,-1,0), Base::Vector3d(-1,0,0) );
addRotItem(cl);
cl = configLine( 3 , "AD", Base::Vector3d(1,0,0), Base::Vector3d(1,0,0), Base::Vector3d(0,1,0),
Base::Vector3d(-1,0,0), Base::Vector3d(0,-1,0), Base::Vector3d(1,0,0) );
addRotItem(cl);
cl = configLine( 4 , "AE", Base::Vector3d(0,0,-1), Base::Vector3d(0,0,-1), Base::Vector3d(0,1,0),
Base::Vector3d(0,0,1), Base::Vector3d(0,-1,0), Base::Vector3d(0,0,-1) );
addRotItem(cl);
cl = configLine( 5 , "BA", Base::Vector3d(0,-1,0), Base::Vector3d(0,1,0), Base::Vector3d(0,0,-1),
Base::Vector3d(0,-1,0), Base::Vector3d(0,0,-1), Base::Vector3d(0,1,0) );
addRotItem(cl);
cl = configLine( 6 , "BC", Base::Vector3d(-1,0,0), Base::Vector3d(-1,0,0), Base::Vector3d(0,0,1),
Base::Vector3d(1,0,0), Base::Vector3d(0,0,-1), Base::Vector3d(-1,0,0) );
addRotItem(cl);
cl = configLine( 7 , "BD", Base::Vector3d(1,0,0), Base::Vector3d(1,0,0), Base::Vector3d(0,0,1),
Base::Vector3d(-1,0,0), Base::Vector3d(0,0,-1), Base::Vector3d(1,0,0) );
addRotItem(cl);
cl = configLine( 8 , "BF", Base::Vector3d(-1,0,0), Base::Vector3d(0,-1,0), Base::Vector3d(0,0,1),
Base::Vector3d(0,1,0), Base::Vector3d(0,0,-1), Base::Vector3d(0,1,0) );
addRotItem(cl);
cl = configLine( 9 , "CA", Base::Vector3d(0,1,0), Base::Vector3d(1,0,0), Base::Vector3d(-1,0,0),
Base::Vector3d(1,0,0), Base::Vector3d(0,1,0), Base::Vector3d(0,1,0) );
addRotItem(cl);
cl = configLine( 10 , "CB", Base::Vector3d(0,0,1), Base::Vector3d(0,0,1), Base::Vector3d(-1,0,0),
Base::Vector3d(0,0,-1), Base::Vector3d(1,0,0), Base::Vector3d(0,0,1) );
addRotItem(cl);
cl = configLine( 11 , "CE", Base::Vector3d(0,0,-1), Base::Vector3d(0,0,-1), Base::Vector3d(-1,0,0),
Base::Vector3d(0,0,1), Base::Vector3d(1,0,0), Base::Vector3d(0,0,-1) );
addRotItem(cl);
cl = configLine( 12 , "CF", Base::Vector3d(0,-1,0), Base::Vector3d(0,-1,0), Base::Vector3d(-1,0,0),
Base::Vector3d(0,1,0), Base::Vector3d(1,0,0), Base::Vector3d(0,-1,0) );
addRotItem(cl);
cl = configLine( 13 , "DA", Base::Vector3d(0,1,0), Base::Vector3d(0,1,0), Base::Vector3d(1,0,0),
Base::Vector3d(0,-1,0), Base::Vector3d(-1,0,0), Base::Vector3d(0,1,0) );
addRotItem(cl);
cl = configLine( 14 , "DB", Base::Vector3d(0,0,1), Base::Vector3d(0,0,1), Base::Vector3d(1,0,0),
Base::Vector3d(0,0,-1), Base::Vector3d(-1,0,0), Base::Vector3d(0,0,1) );
addRotItem(cl);
cl = configLine( 15 , "DE", Base::Vector3d(0,0,-1), Base::Vector3d(0,0,-1), Base::Vector3d(1,0,0),
Base::Vector3d(0,0,1), Base::Vector3d(-1,0,0), Base::Vector3d(0,0,-1) );
addRotItem(cl);
cl = configLine( 16 , "DF", Base::Vector3d(0,-1,0), Base::Vector3d(-1,0,0), Base::Vector3d(1,0,0),
Base::Vector3d(1,0,0), Base::Vector3d(0,-1,0), Base::Vector3d(0,-1,0) );
addRotItem(cl);
cl = configLine( 17 , "EA", Base::Vector3d(0,1,0), Base::Vector3d(0,1,0), Base::Vector3d(0,0,-1),
Base::Vector3d(0,-1,0), Base::Vector3d(0,0,1), Base::Vector3d(0,1,0) );
addRotItem(cl);
cl = configLine( 18 , "EC", Base::Vector3d(-1,0,0), Base::Vector3d(-1,0,0), Base::Vector3d(0,0,-1),
Base::Vector3d(1,0,0), Base::Vector3d(0,0,1), Base::Vector3d(-1,0,0) );
addRotItem(cl);
cl = configLine( 19 , "ED", Base::Vector3d(1,0,0), Base::Vector3d(1,0,0), Base::Vector3d(0,0,-1),
Base::Vector3d(-1,0,0), Base::Vector3d(0,0,1), Base::Vector3d(1,0,0) );
addRotItem(cl);
cl = configLine( 20 , "EF", Base::Vector3d(0,-1,0), Base::Vector3d(0,-1,0), Base::Vector3d(0,0,-1),
Base::Vector3d(0,1,0), Base::Vector3d(0,0,1), Base::Vector3d(-1,0,0) );
addRotItem(cl);
cl = configLine( 21 , "FB", Base::Vector3d(0,0,1), Base::Vector3d(0,0,1), Base::Vector3d(0,-1,0),
Base::Vector3d(0,0,-1), Base::Vector3d(0,1,0), Base::Vector3d(0,0,1) );
addRotItem(cl);
cl = configLine( 22 , "FC", Base::Vector3d(-1,0,0), Base::Vector3d(0,1,0), Base::Vector3d(-1,0,0),
Base::Vector3d(1,0,0), Base::Vector3d(0,1,0), Base::Vector3d(-1,0,0) );
addRotItem(cl);
cl = configLine( 23 , "FD", Base::Vector3d(1,0,0), Base::Vector3d(1,0,0), Base::Vector3d(0,-1,0),
Base::Vector3d(-1,0,0), Base::Vector3d(0,1,0), Base::Vector3d(1,0,0) );
addRotItem(cl);
cl = configLine( 24 , "FE", Base::Vector3d(0,0,-1), Base::Vector3d(0,0,-1), Base::Vector3d(0,-1,0),
Base::Vector3d(0,0,1), Base::Vector3d(0,1,0), Base::Vector3d(0,0,-1) );
addRotItem(cl);

9
src/Mod/TechDraw/Gui/TaskProjGroup.cpp
View File

@ -179,12 +179,9 @@ void TaskProjGroup::on3DClicked(void)
std::pair<Base::Vector3d,Base::Vector3d> dir3D = get3DViewDir();
Base::Vector3d dir = dir3D.first;
Base::Vector3d up = dir3D.second;
Base::Console().Message("TRACE - TPG::on3DClicked - dir: %s up: %s\n",
DrawUtil::formatVector(dir).c_str(),DrawUtil::formatVector(up).c_str());
TechDraw::DrawProjGroupItem* front = multiView->getProjItem("Front");
if (front) { //why "if front"???
Base::Console().Message("TRACE - TPG::on3DClicked - front found\n");
multiView->setTable(dir,up);
setUiPrimary();
Gui::Command::updateActive();
@ -438,11 +435,9 @@ std::pair<Base::Vector3d,Base::Vector3d> TaskProjGroup::get3DViewDir()
viewDir = Base::Vector3d(dvec[0], dvec[1], dvec[2]);
viewUp = Base::Vector3d(upvec[0],upvec[1],upvec[2]);
Base::Console().Message("TRACE - TPG::get3dview - Viewer dir: %s Viewer Up: %s \n",
DrawUtil::formatVector(viewDir).c_str(),DrawUtil::formatVector(viewUp).c_str());
viewDir *= -1.0; //Inventor dir is opposite TD dir, Inventor up is same as TD up
Base::Console().Message("TRACE - TPG::get3dview - (adjusted) Viewer dir: %s Viewer Up: %s \n",
DrawUtil::formatVector(viewDir).c_str(),DrawUtil::formatVector(viewUp).c_str());
viewDir = DrawUtil::closestBasis(viewDir);
viewUp = DrawUtil::closestBasis(viewUp);
result = std::make_pair(viewDir,viewUp);
return result;
}