bool PolyChecker::IntersectProp(const DPoint2 &a, const DPoint2 &b, const DPoint2 &c, const DPoint2 &d)
{
if (Collinear(a, b, c) || Collinear(a, b, d) ||
Collinear(c, d, a) || Collinear(c, d, b))
return false;
return Xor(Left(a, b, c), Left(a, b, d)) && Xor(Left(c, d, a), Left(c, d, b));
}
/*---------------------------------------------------------------------
Returns true iff ab properly intersects cd: they share
a point interior to both segments. The properness of the
intersection is ensured by using strict leftness.
---------------------------------------------------------------------*/
bool IntersectProp( tPointi a, tPointi b, tPointi c, tPointi d )
{
/* Eliminate improper cases. */
if (
Collinear(a,b,c) ||
Collinear(a,b,d) ||
Collinear(c,d,a) ||
Collinear(c,d,b)
)
return FALSE;
return
Xor( Left(a,b,c), Left(a,b,d) )
&& Xor( Left(c,d,a), Left(c,d,b) );
}
bool PolyChecker::Between(const DPoint2 &a, const DPoint2 &b, const DPoint2 &c)
{
DPoint2 ba, ca;
if (!Collinear( a, b, c ))
return false;
if (a.x != b.x)
return ((a.x <= c.x) && (c.x <= b.x)) || ((a.x >= c.x) && (c.x >= b.x));
else
return ((a.y <= c.y) && (c.y <= b.y)) || ((a.y >= c.y) && (c.y >= b.y));
}
/*---------------------------------------------------------------------
DoubleTriangle builds the initial double triangle. It first finds 3
noncollinear points and makes two faces out of them, in opposite order.
It then finds a fourth point that is not coplanar with that face. The
vertices are stored in the face structure in counterclockwise order so
that the volume between the face and the point is negative. Lastly, the
3 newfaces to the fourth point are constructed and the data structures
are cleaned up.
---------------------------------------------------------------------*/
void DoubleTriangle( void )
{
tVertex v0, v1, v2, v3;
tFace f0, f1 = NULL;
int vol;
/* Find 3 noncollinear points. */
v0 = vertices;
while ( Collinear( v0, v0->next, v0->next->next ) )
if ( ( v0 = v0->next ) == vertices )
printf("DoubleTriangle: All points are Collinear!\n"), exit(0);
v1 = v0->next;
v2 = v1->next;
/* Mark the vertices as processed. */
v0->mark = PROCESSED;
v1->mark = PROCESSED;
v2->mark = PROCESSED;
/* Create the two "twin" faces. */
f0 = MakeFace( v0, v1, v2, f1 );
f1 = MakeFace( v2, v1, v0, f0 );
/* Link adjacent face fields. */
f0->edge[0]->adjface[1] = f1;
f0->edge[1]->adjface[1] = f1;
f0->edge[2]->adjface[1] = f1;
f1->edge[0]->adjface[1] = f0;
f1->edge[1]->adjface[1] = f0;
f1->edge[2]->adjface[1] = f0;
/* Find a fourth, noncoplanar point to form tetrahedron. */
v3 = v2->next;
vol = VolumeSign( f0, v3 );
while ( !vol ) {
if ( ( v3 = v3->next ) == v0 )
printf("DoubleTriangle: All points are coplanar!\n"), exit(0);
vol = VolumeSign( f0, v3 );
}
/* Insure that v3 will be the first added. */
vertices = v3;
if ( debug ) {
fprintf(stderr, "DoubleTriangle: finished. Head repositioned at v3.\n");
PrintOut( vertices );
}
}
/*---------------------------------------------------------------------
Returns TRUE iff point c lies on the closed segement ab.
First checks that c is collinear with a and b.
---------------------------------------------------------------------*/
bool Between( tPointi a, tPointi b, tPointi c )
{
tPointi ba, ca;
if ( ! Collinear( a, b, c ) )
return FALSE;
/* If ab not vertical, check betweenness on x; else on y. */
if ( a[X] != b[X] )
return ((a[X] <= c[X]) && (c[X] <= b[X])) ||
((a[X] >= c[X]) && (c[X] >= b[X]));
else
return ((a[Y] <= c[Y]) && (c[Y] <= b[Y])) ||
((a[Y] >= c[Y]) && (c[Y] >= b[Y]));
}
char ParallelInt( tPointi a, tPointi b, tPointi c, tPointi d, tPointd p, tPointd q )
{
/*
printf("ParallelInt: a,b,c,d: (%d,%d), (%d,%d), (%d,%d), (%d,%d)\n",
a[X],a[Y], b[X],b[Y], c[X],c[Y], d[X],d[Y]);
*/
if ( !Collinear( a, b, c) )
return '0';
if ( Between( a, b, c ) && Between( a, b, d ) ) {
Assigndi( p, c );
Assigndi( q, d );
return 'e';
}
if ( Between( c, d, a ) && Between( c, d, b ) ) {
Assigndi( p, a );
Assigndi( q, b );
return 'e';
}
if ( Between( a, b, c ) && Between( c, d, b ) ) {
Assigndi( p, c );
Assigndi( q, b );
return 'e';
}
if ( Between( a, b, c ) && Between( c, d, a ) ) {
Assigndi( p, c );
Assigndi( q, a );
return 'e';
}
if ( Between( a, b, d ) && Between( c, d, b ) ) {
Assigndi( p, d );
Assigndi( q, b );
return 'e';
}
if ( Between( a, b, d ) && Between( c, d, a ) ) {
Assigndi( p, d );
Assigndi( q, a );
return 'e';
}
return '0';
}
char ParallelInt( tPointi a, tPointi b, tPointi c, tPointi d, tPointd p )
{
if ( !Collinear( a, b, c) )
return '0';
if ( Between( a, b, c ) ) {
Assigndi( p, c );
return 'e';
}
if ( Between( a, b, d ) ) {
Assigndi( p, d );
return 'e';
}
if ( Between( c, d, a ) ) {
Assigndi( p, a );
return 'e';
}
if ( Between( c, d, b ) ) {
Assigndi( p, b );
return 'e';
}
return '0';
}
QmitkBulgeToolGUI::QmitkBulgeToolGUI()
:QmitkToolGUI()
{
std::cout << "hi from " << __FUNCSIG__ << std::endl;
// create the visible widgets
QBoxLayout* verticalLayout = new QVBoxLayout( this );
m_HorizontalLayout = new QHBoxLayout();
verticalLayout->addLayout(m_HorizontalLayout);
m_HorizontalLayout1 = new QHBoxLayout();
verticalLayout->addLayout(m_HorizontalLayout1);
m_HorizontalLayout2 = new QHBoxLayout();
verticalLayout->addLayout(m_HorizontalLayout2);
m_SelectSurfaceBox = new QComboBox();
m_HorizontalLayout->addWidget(m_SelectSurfaceBox);
connect(m_SelectSurfaceBox, SIGNAL(activated(int)), this, SLOT(SelectSurface(int)));
m_PbtnSelectSurfaceViaMouse = new QPushButton();
QIcon icn_OpenFile;
icn_OpenFile.addFile(":/threeDEditing/res/threeDEditing/mousepointer.png");
m_PbtnSelectSurfaceViaMouse->setIcon(icn_OpenFile);
m_PbtnSelectSurfaceViaMouse->setFixedSize(22,22);
m_HorizontalLayout->addWidget(m_PbtnSelectSurfaceViaMouse);
connect(m_PbtnSelectSurfaceViaMouse, SIGNAL(clicked()), this, SLOT(SelectSurfaceViaMouse()));
m_PbtnReinitSelection = new QPushButton();
m_PbtnReinitSelection->setText("Reinit Selection");
m_PbtnReinitSelection->setCheckable(true);
m_HorizontalLayout1->addWidget(m_PbtnReinitSelection);
connect(m_PbtnReinitSelection, SIGNAL(clicked()), this, SLOT(ReinitSelection()));
m_PbtnJumpToPosition = new QPushButton();
m_PbtnJumpToPosition->setText("Jump to Position");
m_PbtnJumpToPosition->setCheckable(true);
m_HorizontalLayout1->addWidget(m_PbtnJumpToPosition);
connect(m_PbtnJumpToPosition, SIGNAL(clicked()), this, SLOT(JumpToPosition()));
QLabel* label = new QLabel( "Radius", this );
QFont f = label->font();
f.setBold(false);
label->setFont( f );
m_HorizontalLayout2->addWidget(label);
m_RadiusSlider = new QSlider(Qt::Horizontal);
m_RadiusSlider->setSliderPosition(20);
m_HorizontalLayout2->addWidget(m_RadiusSlider);
QObject::connect(m_RadiusSlider, SIGNAL(sliderMoved(int)), this, SLOT(RadiusChanged(int)));
// Tool Specific
QBoxLayout* horizontalLayout3 = new QHBoxLayout();
verticalLayout->addLayout(horizontalLayout3);
QBoxLayout* horizontalLayout4 = new QHBoxLayout();
verticalLayout->addLayout(horizontalLayout4);
QBoxLayout* horizontalLayout5 = new QHBoxLayout();
verticalLayout->addLayout(horizontalLayout5);
QBoxLayout* horizontalLayout6 = new QHBoxLayout();
verticalLayout->addLayout(horizontalLayout6);
QBoxLayout* horizontalLayout7 = new QHBoxLayout();
verticalLayout->addLayout(horizontalLayout7);
QBoxLayout* horizontalLayout8 = new QHBoxLayout();
verticalLayout->addLayout(horizontalLayout8);
QBoxLayout* horizontalLayout9 = new QHBoxLayout();
verticalLayout->addLayout(horizontalLayout9);
QBoxLayout* horizontalLayout10 = new QHBoxLayout();
verticalLayout->addLayout(horizontalLayout10);
QBoxLayout* horizontalLayout11 = new QHBoxLayout();
verticalLayout->addLayout(horizontalLayout11);
QFrame *frame = new QFrame( this );
frame->setFrameStyle( QFrame::Box | QFrame::Plain );
frame->setLineWidth(10);
frame->setFixedSize(200,10);
QColor color(214,247,202);
QPalette colorPalette(color);
colorPalette.setColor(QPalette::Foreground, color);
frame->setPalette(colorPalette);
horizontalLayout3->addWidget(frame);
QLabel* label2 = new QLabel( "Select move points technique:", this );
QFont f2 = label2->font();
f2.setBold(false);
label->setFont( f2 );
horizontalLayout4->addWidget(label2);
m_pbtn_Collinear = new QPushButton();
m_pbtn_Collinear->setText("Collinear");
m_pbtn_Collinear->setToolTip("Move points in the same direction as the mouse moves.");
m_pbtn_Collinear->setCheckable(true);
m_pbtn_Collinear->setChecked(true);
horizontalLayout5->addWidget(m_pbtn_Collinear);
connect(m_pbtn_Collinear, SIGNAL(clicked()), this, SLOT(Collinear()));
m_pbtn_Radial = new QPushButton();
m_pbtn_Radial->setText("Radial");
m_pbtn_Radial->setToolTip("Move points outside radial from the origin of the tool.");
m_pbtn_Radial->setCheckable(true);
horizontalLayout5->addWidget(m_pbtn_Radial);
connect(m_pbtn_Radial, SIGNAL(clicked()), this, SLOT(Radial()));
QFrame *frame1 = new QFrame( this );
frame1->setFrameStyle( QFrame::Box | QFrame::Plain );
frame1->setLineWidth(10);
frame1->setFixedSize(200,10);
frame1->setPalette(colorPalette);
horizontalLayout6->addWidget(frame1);
QLabel* label3 = new QLabel( "The tool can add further points while bulging.", this );
QFont f3 = label3->font();
f3.setBold(false);
label3->setFont( f );
horizontalLayout7->addWidget(label3);
m_SelectRefinementMethodeBox = new QComboBox();
m_SelectRefinementMethodeBox->addItem("Off. Don't add points");
m_SelectRefinementMethodeBox->addItem("Automatic");
m_SelectRefinementMethodeBox->addItem("Insert Point(s)");
m_SelectRefinementMethodeBox->addItem("Subdivide Edge(s)");
horizontalLayout8->addWidget(m_SelectRefinementMethodeBox);
connect(m_SelectRefinementMethodeBox, SIGNAL(activated(int)), this, SLOT(SelectRefinementMethode(int)));
QFrame *frame2 = new QFrame( this );
frame2->setFrameStyle( QFrame::Box | QFrame::Plain );
frame2->setLineWidth(10);
frame2->setFixedSize(200,10);
frame2->setPalette(colorPalette);
horizontalLayout9->addWidget(frame2);
QPushButton* pbtn_ShowTool = new QPushButton();
pbtn_ShowTool->setText("Show Bulge Tool");
pbtn_ShowTool->setCheckable(true);
horizontalLayout10->addWidget(pbtn_ShowTool);
connect(pbtn_ShowTool, SIGNAL(clicked()), this, SLOT(ShowTool()));
QPushButton* pbtnReinitNow = new QPushButton();
pbtnReinitNow->setText("Reinit Now");
horizontalLayout11->addWidget(pbtnReinitNow);
connect(pbtnReinitNow, SIGNAL(clicked()), this, SLOT(ReinitNow()));
connect(this, SIGNAL(NewToolAssociated(mitk::Tool*)), this, SLOT(OnNewToolAssociated(mitk::Tool*)));
std::cout << "ciao from " << __FUNCSIG__ << std::endl;
}
