mitk::Point2D mitk::PlanarDoubleEllipse::ApplyControlPointConstraints(unsigned int index, const Point2D& point)
{
if (index == 2 && !m_ConstrainCircle)
{
Point2D centerPoint = this->GetControlPoint(0);
Vector2D outerMajorVector = this->GetControlPoint(1) - centerPoint;
Vector2D minorDirection;
minorDirection[0] = outerMajorVector[1];
minorDirection[1] = -outerMajorVector[0];
minorDirection.Normalize();
double outerMajorRadius = outerMajorVector.GetNorm();
double innerMajorRadius = (this->GetControlPoint(3) - centerPoint).GetNorm();
ScalarType radius = std::max(outerMajorRadius - innerMajorRadius, std::min(centerPoint.EuclideanDistanceTo(point), outerMajorRadius));
return centerPoint + minorDirection * radius;
}
else if (index == 3 && !m_ConstrainThickness)
{
Point2D centerPoint = this->GetControlPoint(0);
Vector2D outerMajorVector = this->GetControlPoint(1) - centerPoint;
double outerMajorRadius = outerMajorVector.GetNorm();
double outerMinorRadius = (this->GetControlPoint(2) - centerPoint).GetNorm();
ScalarType radius = std::max(outerMajorRadius - outerMinorRadius, std::min(centerPoint.EuclideanDistanceTo(point), outerMajorRadius));
outerMajorVector.Normalize();
return centerPoint - outerMajorVector * radius;
}
return point;
}
void TextureTest::ProcessEvent(SDL_Event* event)
{
switch(event->type)
{
case SDL_MOUSEBUTTONDOWN:
{
if(event->button.button == 4)
{
}
else if(event->button.button == 5)
{
}
break;
}
case SDL_KEYDOWN:
{
if(event->key.keysym.sym == SDLK_UP)
{
Vector2D oldSteer = v->GetVelocity();
Vector2D temp = v->GetVelocity();
temp.Normalize();
v->SetVelocity(oldSteer+temp*16);
//v->SetHeading(v->GetVelocity());
}
if(event->key.keysym.sym == SDLK_DOWN)
{
Vector2D oldSteer = v->GetVelocity();
Vector2D temp = v->GetVelocity();
temp.Normalize();
v->SetVelocity(oldSteer-temp*163);
}
if(event->key.keysym.sym == SDLK_LEFT)
{
Matrix2D mat;
//Vector2D vec = v->GetVelocity();
Vector2D vecH = v->GetVelocity();
//Vec2DRotateAroundO(vecH,angle);
mat.Rotate(angle);
//
//mat.Rotate(angle);
mat.TransformVector(vecH);
// / mat.TransformVector(vecH);
// //v->SetVelocity(vec);
// v->RotateHeadingToFacePosition(vecH);
//v->SetSteeringForce(vecH);
v->SetVelocity(vecH);
angle=0.07;
}
break;
}
//case SDL_KEYUP
}
}
void Physics::TestCollision(Circle *a, Circle *b) {
Vector2D n = (b->GetCentroidPosition() - a->GetCentroidPosition());
double depth = a->radius + b->radius - n.GetLength();
if (depth < 0) return;
n.Normalize();
constraints.push_back(new Contact(a, b, a->GetCentroidPosition() + n * a->radius, n, depth));
}
Vector2D Slerp(const Vector2D &a, const Vector2D &b, Float t) {
Float dot = Math::WrapFloat(Dot(a, b), -1.0f, 1.0f);
Float theta = acos(dot) * t;
Vector2D relativeVec = b - (a * dot);
relativeVec.Normalize();
return ((a*cos(theta)) + (relativeVec*sin(theta)));
}
void Shape::resolveCollision( Shape & shape )
{
Vector2D delta = position - shape.position;
float d = delta.Length();
Vector2D mtd = delta * ( ( ( getRadius() + shape.getRadius() ) - d ) / d );
float im1 = 1 / getMass();
float im2 = 1 / shape.getMass();
// speed
Vector2D v = velocity - shape.velocity;
float vn = v * (mtd.Normalize());
// intersecting but moving away
if ( vn > 0.0f ) return;
// impulse
float i = (-(1.0f + RESTITUTION) * vn ) / ( im1 + im2 );
Vector2D impulse = mtd * i;
// momentum
velocity += impulse * im1;
shape.velocity -= impulse * im1;
}
void Vector2D::ProjToLine (const Vector2D &rclPt, const Vector2D &rclLine)
{
double l = rclLine.Length();
double t1 = (rclPt * rclLine) / l;
Vector2D clNormal = rclLine;
clNormal.Normalize();
clNormal.Scale(t1);
*this = clNormal;
}
mitk::Point2D mitk::PlanarCircle::ApplyControlPointConstraints(unsigned int index, const Point2D &point)
{
if ( this->GetPlaneGeometry() == nullptr )
{
return point;
}
Point2D indexPoint;
this->GetPlaneGeometry()->WorldToIndex( point, indexPoint );
BoundingBox::BoundsArrayType bounds = this->GetPlaneGeometry()->GetBounds();
if ( indexPoint[0] < bounds[0] ) {
indexPoint[0] = bounds[0];
}
if ( indexPoint[0] > bounds[1] ) {
indexPoint[0] = bounds[1];
}
if ( indexPoint[1] < bounds[2] ) {
indexPoint[1] = bounds[2];
}
if ( indexPoint[1] > bounds[3] ) {
indexPoint[1] = bounds[3];
}
Point2D constrainedPoint;
this->GetPlaneGeometry()->IndexToWorld( indexPoint, constrainedPoint );
if(m_MinMaxRadiusContraintsActive)
{
if( index != 0)
{
const Point2D ¢erPoint = this->GetControlPoint(0);
double euclideanDinstanceFromCenterToPoint1 = centerPoint.EuclideanDistanceTo(point);
Vector2D vectorProjectedPoint;
vectorProjectedPoint = point - centerPoint;
vectorProjectedPoint.Normalize();
if( euclideanDinstanceFromCenterToPoint1 > m_MaxRadius )
{
vectorProjectedPoint *= m_MaxRadius;
constrainedPoint = centerPoint;
constrainedPoint += vectorProjectedPoint;
}
else if( euclideanDinstanceFromCenterToPoint1 < m_MinRadius )
{
vectorProjectedPoint *= m_MinRadius;
constrainedPoint = centerPoint;
constrainedPoint += vectorProjectedPoint;
}
}
}
return constrainedPoint;
}
TEST(vec2d, norm)
{
Vector2D testingVector = Vector2D();
testingVector.x = 1;
testingVector.y = 0;
testingVector.Magnitude();
testingVector.Normalize();
EXPECT_FLOAT_EQ(1.f, testingVector.x);
EXPECT_FLOAT_EQ(0.f, testingVector.y);
}
void mitk::PlanarEllipse::GeneratePolyLine()
{
// clear the PolyLine-Contrainer, it will be reconstructed soon enough...
this->ClearPolyLines();
const Point2D ¢erPoint = GetControlPoint( 0 );
const Point2D &boundaryPoint1 = GetControlPoint( 1 );
const Point2D &boundaryPoint2 = GetControlPoint( 2 );
Vector2D dir = boundaryPoint1 - centerPoint; dir.Normalize();
vnl_matrix_fixed<float, 2, 2> rot;
// differentiate between clockwise and counterclockwise rotation
int start = 0;
int end = 64;
if (dir[1]<0)
{
dir[0] = -dir[0];
start = -32;
end = 32;
}
// construct rotation matrix to align ellipse with control point vector
rot[0][0] = dir[0];
rot[1][1] = rot[0][0];
rot[1][0] = sin(acos(rot[0][0]));
rot[0][1] = -rot[1][0];
double radius1 = centerPoint.EuclideanDistanceTo( boundaryPoint1 );
double radius2 = centerPoint.EuclideanDistanceTo( boundaryPoint2 );
// Generate poly-line with 64 segments
for ( int t = start; t < end; ++t )
{
double alpha = (double) t * vnl_math::pi / 32.0;
// construct the new polyline point ...
vnl_vector_fixed< float, 2 > vec;
vec[0] = radius1 * cos( alpha );
vec[1] = radius2 * sin( alpha );
vec = rot*vec;
Point2D polyLinePoint;
polyLinePoint[0] = centerPoint[0] + vec[0];
polyLinePoint[1] = centerPoint[1] + vec[1];
// ... and append it to the PolyLine.
// No extending supported here, so we can set the index of the PolyLineElement to '0'
AppendPointToPolyLine( 0, PolyLineElement( polyLinePoint, 0 ) );
}
AppendPointToPolyLine( 1, PolyLineElement( centerPoint, 0 ) );
AppendPointToPolyLine( 1, PolyLineElement( GetControlPoint( 3 ), 0 ) );
}
void mitk::GizmoInteractor::RotateAroundAxis(StateMachineAction*,
InteractionEvent* interactionEvent)
{
auto positionEvent = dynamic_cast<const InteractionPositionEvent*>(interactionEvent);
if(positionEvent == NULL)
{
return;
}
Vector2D originalVector = m_InitialClickPosition2D - m_InitialGizmoCenter2D;
Vector2D currentVector = positionEvent->GetPointerPositionOnScreen() - m_InitialGizmoCenter2D;
originalVector.Normalize();
currentVector.Normalize();
double angle_rad = std::atan2(currentVector[1], currentVector[0]) -
std::atan2(originalVector[1], originalVector[0]);
ApplyRotationToManipulatedObject(vtkMath::DegreesFromRadians(angle_rad));
RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
void IFSMCowFlee::Calculate(MovingEntity* entity, Instance* instance){
Rabbit* target = instance->GetRabbit();
Vector2D newHeading = (entity->GetPosition() - target->GetPosition());
newHeading.Normalize();
entity->SetHeading(newHeading);
entity->Move(0.0f);
}
bool Sector::Intersects(const Vector2D& position) const {
Vector2D l(this->GetPosition() - position);
if(l.GetLength() > GetRadius()) return false;
if(Math::IsEqual(l.GetLength(), 0.0)) return true;
Vector2D sF = Vector2D::GetFacingVector(this->GetArcCenter(), this->GetPosition());
Vector2D sF_n(sF.Normalize());
Vector2D P_to_S(l.Normalize());
double angle = std::acos(Vector2D::DotProduct(sF_n, P_to_S));
return (angle <= GetTheta() / 2.0);
}
void DumbTank::Update(float deltaTime, SDL_Event e)
{
//This is a dumb tank. Do NOT copy this approach.
//Did we see a tank?
if(mTanksICanSee.size() == 0)
{
ChangeState(TANKSTATE_IDLE);
//If there are no visible tanks, then keep moving.
//Check if we reached position before turning.
if(mPosition.y < mPosition1.y && mHeading.y != -1.0f)
{
mHeading = Vector2D(0.0f, -1.0f);
mRotationAngle = 180.0f;
mVelocity = Vector2D();
return;
}
else if(mPosition.y > mPosition2.y && mHeading.y != 1.0f)
{
mHeading = Vector2D(0.0f, 1.0f);
mRotationAngle = 0.0f;
mVelocity = Vector2D();
return;
}
else
{
//Move if we are facing the correct direction.
mCurrentSpeed -= kSpeedIncrement*deltaTime;
if(mCurrentSpeed < -GetMaxSpeed())
mCurrentSpeed = -GetMaxSpeed();
}
}
else
{
//Rotate man to face enemy tank.
Vector2D toTarget = mTanksICanSee[0]->GetCentralPosition()-GetCentralPosition();
toTarget.Normalize();
double dot = toTarget.Dot(mManFireDirection);
if(dot < 0.95f)
RotateManByRadian(kManTurnRate, -1, deltaTime);
//Otherwise stop moving and fire at the visible tank.
mVelocity = Vector2D();
ChangeState(TANKSTATE_MANFIRE);
}
BaseTank::Update(deltaTime, e);
}
void BaseTank::Rebound(Vector2D position)
{
//DEBUG: Alert on colliding.
//cout << "Collision" << endl;
//We need to rebound, but which direction?
Vector2D newHeading = GetCentralPosition()-position;
newHeading.Normalize();
//Flip the y coordinate because of the 0,0 position of SDL.
newHeading.y *= -1.0f;
//Set new velocity.
mVelocity = newHeading*-kReboundSpeed;
//Cut the speed.
mCurrentSpeed = 0.0f;
}
void IFSMCowFindGun::Calculate(MovingEntity* entity, Instance* instance){
Gun* target = instance->GetGun();
if (entity->GetPosition().DistanceBetween(target->GetPosition()) <= CATCH_DISTANCE)
{
//switch states
printf("[Cow] found the Gun!\n");
entity->SetState(new IFSMCowHide());
instance->ResetEntities(false, false, false, true);
return;
}
Vector2D newHeading = (target->GetPosition() - entity->GetPosition());
newHeading.Normalize();
entity->SetHeading(newHeading);
entity->Move(0.0f);
}
Vector2D ANCFBeamBE2D::GetInplaneUnitVector2DD(const double& p_loc) const
{
Vector2D rx = GetPosx2DD(p_loc);
rx.Normalize();
return Vector2D(-rx(2), rx(1));
};
Vector2D Nlerp(const Vector2D &a, const Vector2D &b, Float t) {
Vector2D v;
Lerp(a, b, t, &v);
v.Normalize();
return v;
}
Vector2D Vector2D::DirectionVectorBetweenTwoPoints(const Vector2D &v1, const Vector2D & v2)
{
Vector2D vec = Vector2D(v2.x-v1.x,v2.y-v1.y);
return vec.Normalize();
}
void DrawRain( void )
{
if (FirstChainDrip.p_Next == NULL)
return; // no drips to draw
float visibleHeight = Rain.globalHeight - SNOWFADEDIST;
// usual triapi stuff
HSPRITE hsprTexture;
if( Rain.weatherMode == 0 )
hsprTexture = LoadSprite("sprites/effects/rain.spr");
else
hsprTexture = LoadSprite("sprites/effects/snowflake.spr");
const model_s *pTexture = gEngfuncs.GetSpritePointer(hsprTexture);
gEngfuncs.pTriAPI->SpriteTexture( (struct model_s *)pTexture, 0 );
gEngfuncs.pTriAPI->RenderMode( kRenderTransAdd );
gEngfuncs.pTriAPI->CullFace( TRI_NONE );
// go through drips list
cl_drip* Drip = FirstChainDrip.p_Next;
cl_entity_t *player = gEngfuncs.GetLocalPlayer();
if ( Rain.weatherMode == 0 ) // draw rain
{
while (Drip != NULL)
{
cl_drip* nextdDrip = Drip->p_Next;
Vector2D toPlayer;
toPlayer.x = player->origin[0] - Drip->origin[0];
toPlayer.y = player->origin[1] - Drip->origin[1];
toPlayer = toPlayer.Normalize();
toPlayer.x *= DRIP_SPRITE_HALFWIDTH;
toPlayer.y *= DRIP_SPRITE_HALFWIDTH;
float shiftX = (Drip->xDelta / DRIPSPEED) * DRIP_SPRITE_HALFHEIGHT;
float shiftY = (Drip->yDelta / DRIPSPEED) * DRIP_SPRITE_HALFHEIGHT;
// --- draw triangle --------------------------
gEngfuncs.pTriAPI->Color4f( 1.0, 1.0, 1.0, Drip->alpha );
gEngfuncs.pTriAPI->Begin( TRI_TRIANGLES );
gEngfuncs.pTriAPI->TexCoord2f( 0, 0 );
gEngfuncs.pTriAPI->Vertex3f( Drip->origin[0]-toPlayer.y - shiftX, Drip->origin[1]+toPlayer.x - shiftY,Drip->origin[2] + DRIP_SPRITE_HALFHEIGHT );
gEngfuncs.pTriAPI->TexCoord2f( 0.5, 1 );
gEngfuncs.pTriAPI->Vertex3f( Drip->origin[0] + shiftX, Drip->origin[1] + shiftY, Drip->origin[2]-DRIP_SPRITE_HALFHEIGHT );
gEngfuncs.pTriAPI->TexCoord2f( 1, 0 );
gEngfuncs.pTriAPI->Vertex3f( Drip->origin[0]+toPlayer.y - shiftX, Drip->origin[1]-toPlayer.x - shiftY, Drip->origin[2]+DRIP_SPRITE_HALFHEIGHT);
gEngfuncs.pTriAPI->End();
// --- draw triangle end ----------------------
Drip = nextdDrip;
}
}
else // draw snow
{
vec3_t normal;
gEngfuncs.GetViewAngles((float*)normal);
float matrix[3][4];
AngleMatrix (normal, matrix); // calc view matrix
while (Drip != NULL)
{
cl_drip* nextdDrip = Drip->p_Next;
matrix[0][3] = Drip->origin[0]; // write origin to matrix
matrix[1][3] = Drip->origin[1];
matrix[2][3] = Drip->origin[2];
// apply start fading effect
float alpha = (Drip->origin[2] <= visibleHeight) ? Drip->alpha : ((Rain.globalHeight - Drip->origin[2]) / (float)SNOWFADEDIST) * Drip->alpha;
// --- draw quad --------------------------
gEngfuncs.pTriAPI->Color4f( 1.0, 1.0, 1.0, alpha );
gEngfuncs.pTriAPI->Begin( TRI_QUADS );
gEngfuncs.pTriAPI->TexCoord2f( 0, 0 );
SetPoint(0, SNOW_SPRITE_HALFSIZE ,SNOW_SPRITE_HALFSIZE, matrix);
gEngfuncs.pTriAPI->TexCoord2f( 0, 1 );
SetPoint(0, SNOW_SPRITE_HALFSIZE ,-SNOW_SPRITE_HALFSIZE, matrix);
gEngfuncs.pTriAPI->TexCoord2f( 1, 1 );
SetPoint(0, -SNOW_SPRITE_HALFSIZE ,-SNOW_SPRITE_HALFSIZE, matrix);
gEngfuncs.pTriAPI->TexCoord2f( 1, 0 );
SetPoint(0, -SNOW_SPRITE_HALFSIZE ,SNOW_SPRITE_HALFSIZE, matrix);
gEngfuncs.pTriAPI->End();
// --- draw quad end ----------------------
Drip = nextdDrip;
}
}
}
void mitk::PlanarDoubleEllipse::GeneratePolyLine()
{
this->ClearPolyLines();
Point2D centerPoint = this->GetControlPoint(0);
Point2D outerMajorPoint = this->GetControlPoint(1);
Vector2D direction = outerMajorPoint - centerPoint;
direction.Normalize();
const ScalarType deltaAngle = vnl_math::pi / (m_NumberOfSegments / 2);
int start = 0;
int end = m_NumberOfSegments;
if (direction[1] < 0.0)
{
direction[0] = -direction[0];
end = m_NumberOfSegments / 2;
start = -end;
}
vnl_matrix_fixed<mitk::ScalarType, 2, 2> rotation;
rotation[1][0] = std::sin(std::acos(direction[0]));
rotation[0][0] = direction[0];
rotation[1][1] = direction[0];
rotation[0][1] = -rotation[1][0];
ScalarType outerMajorRadius = centerPoint.EuclideanDistanceTo(outerMajorPoint);
ScalarType outerMinorRadius = centerPoint.EuclideanDistanceTo(this->GetControlPoint(2));
ScalarType innerMajorRadius = centerPoint.EuclideanDistanceTo(this->GetControlPoint(3));
ScalarType innerMinorRadius = innerMajorRadius - (outerMajorRadius - outerMinorRadius);
ScalarType angle;
ScalarType cosAngle;
ScalarType sinAngle;
vnl_vector_fixed<mitk::ScalarType, 2> vector;
Point2D point;
for (int i = start; i < end; ++i)
{
angle = i * deltaAngle;
cosAngle = std::cos(angle);
sinAngle = std::sin(angle);
vector[0] = outerMajorRadius * cosAngle;
vector[1] = outerMinorRadius * sinAngle;
vector = rotation * vector;
point[0] = centerPoint[0] + vector[0];
point[1] = centerPoint[1] + vector[1];
this->AppendPointToPolyLine(0, point);
vector[0] = innerMajorRadius * cosAngle;
vector[1] = innerMinorRadius * sinAngle;
vector = rotation * vector;
point[0] = centerPoint[0] + vector[0];
point[1] = centerPoint[1] + vector[1];
this->AppendPointToPolyLine(1, point);
}
}
void mitk::SurfaceGLMapper2D::PaintCells(mitk::BaseRenderer* renderer, vtkPolyData* contour,
const PlaneGeometry* worldGeometry,
const DisplayGeometry* displayGeometry,
vtkLinearTransform * vtktransform,
vtkLookupTable *lut,
vtkPolyData* original3DObject)
{
// deprecated settings
bool usePointData = false;
bool useCellData = false;
this->GetDataNode()->GetBoolProperty("deprecated useCellDataForColouring", useCellData, renderer);
bool scalarVisibility = false;
this->GetDataNode()->GetBoolProperty("scalar visibility", scalarVisibility, renderer);
if(scalarVisibility)
{
VtkScalarModeProperty* scalarMode;
if(this->GetDataNode()->GetProperty(scalarMode, "scalar mode", renderer))
{
if( (scalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_POINT_DATA) ||
(scalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_DEFAULT) )
{
usePointData = true;
}
if(scalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_CELL_DATA)
{
useCellData = true;
}
}
else
{
usePointData = true;
}
}
vtkPoints *vpoints = contour->GetPoints();
vtkDataArray *vpointscalars = contour->GetPointData()->GetScalars();
vtkCellArray *vlines = contour->GetLines();
vtkDataArray* vcellscalars = contour->GetCellData()->GetScalars();
Point3D p; Point2D p2d, last;
int i, j;
int numberOfLines = vlines->GetNumberOfCells();
glLineWidth( m_LineWidth );
glBegin (GL_LINES);
glColor4fv(m_LineColor);
double distanceSinceLastNormal(0.0);
vlines->InitTraversal();
for(i=0;i<numberOfLines;++i)
{
vtkIdType *cell(NULL);
vtkIdType cellSize(0);
double vp[3];
vlines->GetNextCell(cellSize, cell);
vpoints->GetPoint(cell[0], vp);
//take transformation via vtktransform into account
vtktransform->TransformPoint(vp, vp);
vtk2itk(vp, p);
//convert 3D point (in mm) to 2D point on slice (also in mm)
worldGeometry->Map(p, p2d);
//convert point (until now mm and in world coordinates) to display coordinates (units )
displayGeometry->WorldToDisplay(p2d, p2d);
last=p2d;
for(j=1; j<cellSize; ++j)
{
vpoints->GetPoint(cell[j], vp);
Point3D originalPoint;
vtk2itk(vp, originalPoint);
//take transformation via vtktransform into account
vtktransform->TransformPoint(vp, vp);
vtk2itk(vp, p);
//convert 3D point (in mm) to 2D point on slice (also in mm)
worldGeometry->Map(p, p2d);
//convert point (until now mm and in world coordinates) to display coordinates (units )
displayGeometry->WorldToDisplay(p2d, p2d);
double color[3];
if (useCellData && vcellscalars != NULL )
{
// color each cell according to cell data
lut->GetColor( vcellscalars->GetComponent(i,0),color);
glColor3f(color[0],color[1],color[2]);
glVertex2f(last[0], last[1]);
glVertex2f(p2d[0], p2d[1]);
}
else if (usePointData && vpointscalars != NULL )
{
lut->GetColor( vpointscalars->GetComponent(cell[j-1],0),color);
glColor3f(color[0],color[1],color[2]);
glVertex2f(last[0], last[1]);
lut->GetColor( vpointscalars->GetComponent(cell[j],0),color);
glColor3f(color[0],color[1],color[2]);
glVertex2f(p2d[0], p2d[1]);
}
else
{
glVertex2f(last[0], last[1]);
glVertex2f(p2d[0], p2d[1]);
// draw normals ?
if (m_DrawNormals && original3DObject)
{
distanceSinceLastNormal += sqrt((p2d[0]-last[0])*(p2d[0]-last[0]) + (p2d[1]-last[1])*(p2d[1]-last[1]));
if (distanceSinceLastNormal >= 5.0)
{
distanceSinceLastNormal = 0.0;
vtkPointData* pointData = original3DObject->GetPointData();
if (!pointData) break;
vtkDataArray* normalsArray = pointData->GetNormals();
if (!normalsArray) break;
// find 3D point closest to the currently drawn point
double distance(0.0);
vtkIdType closestPointId = m_PointLocator->FindClosestPoint(originalPoint[0], originalPoint[1], originalPoint[2], distance);
if (closestPointId >= 0)
{
// find normal of 3D object at this 3D point
double* normal = normalsArray->GetTuple3(closestPointId);
double transformedNormal[3];
vtktransform->TransformNormal(normal, transformedNormal);
Vector3D normalITK;
vtk2itk(transformedNormal, normalITK);
normalITK.Normalize();
// calculate a point (point from the cut 3D object) + (normal vector of closest point)
Point3D tip3D = p + normalITK;
// map this point into our 2D coordinate system
Point2D tip2D;
worldGeometry->Map(tip3D, tip2D);
displayGeometry->WorldToDisplay(tip2D, tip2D);
// calculate 2D vector from point to point+normal, normalize it to standard length
Vector2D tipVectorGLFront = tip2D - p2d;
tipVectorGLFront.Normalize();
tipVectorGLFront *= m_FrontNormalLengthInPixels;
Vector2D tipVectorGLBack = p2d - tip2D;
tipVectorGLBack.Normalize();
tipVectorGLBack *= m_BackNormalLengthInPixels;
Point2D tipPoint2D = p2d + tipVectorGLFront;
Point2D backTipPoint2D = p2d + tipVectorGLBack;
// draw normalized mapped normal vector
glColor4f(m_BackSideColor[0], m_BackSideColor[1], m_BackSideColor[2], m_BackSideColor[3]); // red backside
glVertex2f(p2d[0], p2d[1]);
glVertex2f(tipPoint2D[0], tipPoint2D[1]);
glColor4f(m_FrontSideColor[0], m_FrontSideColor[1], m_FrontSideColor[2], m_FrontSideColor[3]); // green backside
glVertex2f(p2d[0], p2d[1]);
glVertex2f(backTipPoint2D[0], backTipPoint2D[1]);
glColor4fv(m_LineColor); // back to line color
}
}
}
}
last=p2d;
}
}
glEnd();
glLineWidth(1.0);
}
bool mitk::PlanarDoubleEllipse::SetControlPoint(unsigned int index, const Point2D& point, bool createIfDoesNotExist)
{
switch (index)
{
case 0:
{
Point2D centerPoint = this->GetControlPoint(0);
Vector2D vector = point - centerPoint;
Superclass::SetControlPoint(0, point, createIfDoesNotExist);
Superclass::SetControlPoint(1, this->GetControlPoint(1) + vector, createIfDoesNotExist);
Superclass::SetControlPoint(2, this->GetControlPoint(2) + vector, createIfDoesNotExist);
Superclass::SetControlPoint(3, this->GetControlPoint(3) + vector, createIfDoesNotExist);
break;
}
case 1:
{
Vector2D vector = point - this->GetControlPoint(1);
Superclass::SetControlPoint(1, point, createIfDoesNotExist);
Point2D centerPoint = this->GetControlPoint(0);
Vector2D outerMajorVector = point - centerPoint;
Vector2D outerMinorVector;
outerMinorVector[0] = outerMajorVector[1];
outerMinorVector[1] = -outerMajorVector[0];
if (!m_ConstrainCircle)
{
outerMinorVector.Normalize();
outerMinorVector *= centerPoint.EuclideanDistanceTo(this->GetControlPoint(2));
}
Superclass::SetControlPoint(2, centerPoint + outerMinorVector, createIfDoesNotExist);
Vector2D innerMajorVector = outerMajorVector;
if (!m_ConstrainThickness)
{
innerMajorVector.Normalize();
innerMajorVector *= centerPoint.EuclideanDistanceTo(this->GetControlPoint(3) - vector);
}
Superclass::SetControlPoint(3, centerPoint - innerMajorVector, createIfDoesNotExist);
break;
}
case 2:
{
m_ConstrainCircle = false;
Superclass::SetControlPoint(2, point, createIfDoesNotExist);
break;
}
case 3:
{
m_ConstrainThickness = false;
Superclass::SetControlPoint(3, point, createIfDoesNotExist);
break;
}
default:
return false;
}
return true;
}
